Agent skill

Code Structure

MITAuto-check passedDevelopment

Install Code Structure

skills CLI

$ npx skills add vvedantb/eva --skill code-structure -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install vvedantb/eva code-structure --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/vvedantb/eva.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/code-structure .claude/skills/code-structure && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "code-structure" agent skill from https://github.com/vvedantb/eva/tree/main/.agents/skills/code-structure into .claude/skills/code-structure/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "code-structure", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/vvedantb/eva/tree/main/.agents/skills/code-structure

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add vvedantb/eva --skill code-structure -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install vvedantb/eva code-structure --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/vvedantb/eva.git skills-src && mkdir -p .agents/skills && cp -r skills-src/.agents/skills/code-structure .agents/skills/code-structure && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "code-structure" agent skill from https://github.com/vvedantb/eva/tree/main/.agents/skills/code-structure into .agents/skills/code-structure/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "code-structure", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add vvedantb/eva --skill code-structure -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install vvedantb/eva code-structure --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/vvedantb/eva.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/.agents/skills/code-structure .cursor/skills/code-structure && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "code-structure" agent skill from https://github.com/vvedantb/eva/tree/main/.agents/skills/code-structure into .cursor/skills/code-structure/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "code-structure", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/vvedantb/eva.git --path .agents/skills/code-structure

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add vvedantb/eva --skill code-structure -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install vvedantb/eva code-structure --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/vvedantb/eva.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/.agents/skills/code-structure .gemini/skills/code-structure && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "code-structure" agent skill from https://github.com/vvedantb/eva/tree/main/.agents/skills/code-structure into .gemini/skills/code-structure/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "code-structure", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install vvedantb/eva code-structure

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add vvedantb/eva --skill code-structure -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/vvedantb/eva.git skills-src && mkdir -p .github/skills && cp -r skills-src/.agents/skills/code-structure .github/skills/code-structure && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "code-structure" agent skill from https://github.com/vvedantb/eva/tree/main/.agents/skills/code-structure into .github/skills/code-structure/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "code-structure", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add vvedantb/eva --skill code-structure -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install vvedantb/eva code-structure --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/vvedantb/eva.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/.agents/skills/code-structure .opencode/skills/code-structure && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "code-structure" agent skill from https://github.com/vvedantb/eva/tree/main/.agents/skills/code-structure into .opencode/skills/code-structure/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "code-structure", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: code-structure
GitHub stars: 101
Used in: 2 other repos
Token cost: ~1.1k tokens
SKILL.md length: 363 words
Files: 1
Skills in repo: 23
Repo updated: Oct 6, 2026
First seen: Oct 7, 2026
Licence: MIT

At a glance

Works in 6 steps: Write the flow in action code first… → Mark repeated operational chunks across… → Extract only repeated, non-domain chunks… → …
Multiple workflows duplicate the same operational logic
SKILL.md covers Overview, When to Use, Core Pattern and Quick Reference, plus 5 more sections
Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Code Structure is an agent skill from vvedantb/eva. Use when multiple workflows duplicate the same operational logic, when deciding what belongs in actions vs shared services, or when refactoring repeated operational blocks across domain flows. Use when adding new features that share mechanics with existing ones.

Its SKILL.md is about 1.1k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Refactoring. The repository describes itself as: Orchestrate sandboxed agents that run in the cloud while you work. The licence is MIT.

When your agent uses it

Multiple workflows duplicate the same operational logic
Deciding what belongs in actions vs shared services
Refactoring repeated operational blocks across domain flows
Adding new features that share mechanics with existing ones

Example prompts

“/code-structure”

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

Write the flow in action code first (clear behavior)
Mark repeated operational chunks across callers
Extract only repeated, non-domain chunks to service
Replace one caller → verify → replace remaining callers
Keep domain policy in actions (auth, status transitions, error classification)
Run verification: typecheck, lint, confirm all flows still work

What it can do on your machine

Read from SKILL.md and the folder at commit 166d464. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
No scripts in the folder and no shell commands in SKILL.md (its code samples are typescript).
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Code Structure loads about 1.1k tokens when it runs. Until then it costs about 69 tokens; SKILL.md has 363 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~69
When it runs · the whole SKILL.md, loaded when a task matches: ~1.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from vvedantb/eva at commit 166d464, republished under its MIT licence (© vvedantb). 363 words, ~1,124 tokens.

Download SKILL.mdSave it as .claude/skills/code-structure/SKILL.md (or your agent's skills folder).

name: code-structure
description: Use when multiple workflows duplicate the same operational logic, when deciding what belongs in actions vs shared services, or when refactoring repeated operational blocks across domain flows. Use when adding new features that share mechanics with existing ones.

Service Layer Architecture

Overview

Two-layer separation: Actions orchestrate domain rules (the "why/when"), while a service layer centralizes reusable operational mechanics (the "how").

This prevents duplicated code, inconsistent behavior, and bugs fixed in one path but not others.

When to Use

Multiple callers need the same low-level operation (sandbox creation, email sending, payment processing)
You're copy-pasting operational logic between action files
A bug fix in one workflow doesn't propagate to others doing the same thing
Adding a new feature that shares mechanics with existing flows

Don't use when: Logic is truly domain-specific and used by only one caller.

Core Pattern

Orchestration Layer (Actions)          Service Layer (Shared Mechanics)
├── owns business rules                ├── owns reusable operations
├── owns state transitions             ├── owns provider/SDK interactions
├── owns auth/ownership checks         ├── owns command execution details
├── owns failure classification        ├── owns health checks / readiness
├── owns retries / user-facing errors  └── returns structured results
└── calls service functions

Rule of thumb:

"What this product flow means" → keep in actions
"How to do this operation reliably" → move to service layer

Quick Reference

Design Principle	Do	Don't
API shape	Composable capability blocks	One giant "do everything" method
Inputs/outputs	Explicit params, structured returns	Hidden global state, reaching into DB
Migration	Extract one block, replace one caller, verify, then migrate rest	Refactor everything at once
Domain logic	Keep auth, policy, error classification in actions	Let service mutate domain state directly
Extraction trigger	Logic repeated across 2+ callers	Logic used once (over-abstraction)

Designing Service Functions

Design as capability blocks, not monoliths:

// Good: composable, each caller chooses what to use
createManagedSandbox(...)
prepareRepo(...)
detectPackageManager(...)
installDependencies(...)
runBuildCommand(...)
startSandboxRuntime(...)

Each function should:

Accept all required data as explicit parameters
Return structured outputs (e.g., { ready, previewUrl, proxyPort })
Never reach into database/state directly
Make failure explicit (structured results, not swallowed errors)

This lets callers choose strict vs relaxed behavior per flow.

Show full SKILL.md (126 more words)Show less

Migration Checklist

When extracting shared logic:

Write the flow in action code first (clear behavior)
Mark repeated operational chunks across callers
Extract only repeated, non-domain chunks to service
Replace one caller → verify → replace remaining callers
Keep domain policy in actions (auth, status transitions, error classification)
Run verification: typecheck, lint, confirm all flows still work

Anti-Patterns

Anti-Pattern	Problem
God service	One huge function hides all control flow
Leaky service	Service mutates database tables directly
Inconsistent API	Each function uses different argument styles and error semantics
Over-abstraction	Extracting logic used by only one caller

Example: Email Service (Simple)

// emailService.ts — shared mechanics
export async function sendWelcomeEmail(params: { to: string; name: string }) {
  const html = `<h1>Welcome ${params.name}</h1>`;
  await emailProvider.send(params.to, "Welcome", html);
}

// userSignup.ts — orchestration (owns WHEN to send)
if (user.marketingOptIn) {
  await sendWelcomeEmail({ to: user.email, name: user.name });
}

// adminInvite.ts — orchestration (different business rule, same mechanic)
await sendWelcomeEmail({ to: invitee.email, name: invitee.name });

Mental Model

New feature? → Write in action first → See repeated ops? → Extract to service
                                      → No repetition?  → Keep in action

Your architecture in one sentence: Actions orchestrate domain rules, while the service layer centralizes reusable operational mechanics with a composable, explicit-input API.

Files

Just SKILL.md in .agents/skills/code-structure of vvedantb/eva.

Open the folder on GitHubat commit 166d464

Used in 2 other repositories

We found 3 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 2 other GitHub owners. This page covers the copy in vvedantb/eva, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Code Structure next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Code Structure compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Code Structure this skillvvedantb/eva	101	2 repos	~1.1k	Automated safety check: Pass	MIT	today
Guidelinesakash-network/node	1.1k	22 repos	~577	Automated safety check: Pass	MIT	today
Component Refactoringlangflow-ai/langflow	156k	—	~3.5k	Automated safety check: Pass	MIT	today
Migrate Core Code to Submodulestinyhumansai/openhuman	41k	—	~2.6k	Automated safety check: Pass	GPL-3.0	today
ast-grep Structural Searchcode-yeongyu/oh-my-openagent	70k	—	~3.3k	Automated safety check: Pass	MIT	today
Systematic Code Refactoringluongnv89/claude-howto	42k	—	~3k	Automated safety check: Pass	MIT	7 days ago

Similar skills

Guidelines
akash-network/node
Behavioral guidelines to reduce common LLM coding mistakes. An agent skill from akash-network/node.
1.1k GitHub starsUsed in 22 repos~577 tokens
DevelopmentAuto-check passed
Component Refactoring
langflow-ai/langflow
Refactor high-complexity React components in Langflow frontend.
156k GitHub stars~3.5k tokensUpdated today
DevelopmentAuto-check passed
Migrate Core Code to Submodules
tinyhumansai/openhuman
Plans and carries out moving non-host-specific code and its tests from the OpenHuman core into vendored tiny submodule libraries, then releases the submodule and re-pins the host.
41k GitHub stars~2.6k tokensUpdated today
DevelopmentAuto-check passed
ast-grep Structural Search
code-yeongyu/oh-my-openagent
Searches and rewrites code by syntax-tree shape across 25 languages with ast-grep, for codemods, structural queries and YAML lint rules, using a Python wrapper script.
70k GitHub stars~3.3k tokensUpdated today
DevelopmentAuto-check passed
Systematic Code Refactoring
luongnv89/claude-howto
Guides refactoring in phases based on Martin Fowler's method: research, test coverage check, planning and small tested steps, with your approval at each phase.
42k GitHub stars~3k tokensUpdated 7 days ago
DevelopmentAuto-check passed
Codex
skills-directory/skill-codex
A skill your agent uses when the user asks to run Codex CLI (codex exec, codex resume) or references OpenAI Codex for code analysis, refactoring, or automated editing
1.5k GitHub starsUsed in 3 repos~1.8k tokens
DevelopmentAuto-check passed

Questions about Code Structure

What does Code Structure do?

A skill your agent uses when multiple workflows duplicate the same operational logic, when deciding what belongs in actions vs shared services, or when refactoring repeated operational blocks across…. Code Structure is an agent skill from vvedantb/eva. Use when multiple workflows duplicate the same operational logic, when deciding what belongs in actions vs shared services, or when refactoring repeated operational blocks across domain flows.

When should I use Code Structure?

Code Structure fits situations like: multiple workflows duplicate the same operational logic; deciding what belongs in actions vs shared services; refactoring repeated operational blocks across domain flows; adding new features that share mechanics with existing ones.

How do I install Code Structure in Claude Code?

Run `npx skills add vvedantb/eva --skill code-structure -a claude-code`. Or copy the skill folder (.agents/skills/code-structure in vvedantb/eva) into .claude/skills/code-structure in your project. Claude Code loads it when a task matches its description.

How do I install Code Structure in Codex?

Run `npx skills add vvedantb/eva --skill code-structure -a codex`. Or copy the skill folder (.agents/skills/code-structure in vvedantb/eva) into .agents/skills/code-structure in your project. Codex loads it when a task matches its description.

Can I use Code Structure in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add vvedantb/eva --skill code-structure -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/code-structure, .gemini/skills/code-structure, .github/skills/code-structure and .opencode/skills/code-structure in your project.

What does Code Structure need to run?

SKILL.md names no scripts, command-line tools or credentials: Code Structure is instructions for the agent only.

Does Code Structure access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Code Structure safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Code Structure use?

Code Structure is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Code Structure use?

About 1.1k tokens (SKILL.md is roughly 4.5k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Code Structure?

Skills that share tags, products or a category with Code Structure: Guidelines (akash-network/node, 1.1k stars), Component Refactoring (langflow-ai/langflow, 156k stars), Migrate Core Code to Submodules (tinyhumansai/openhuman, 41k stars) and ast-grep Structural Search (code-yeongyu/oh-my-openagent, 70k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Code Structure?

vvedantb (a GitHub user) maintains it in vvedantb/eva, which has 101 GitHub stars. The repository holds 23 skills in this directory. The repository was last updated on October 6, 2026.

Source: vvedantb/eva on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install Code Structure

Facts

At a glance

What it does

When your agent uses it

Example prompts

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

Service Layer Architecture

Overview

When to Use

Core Pattern

Quick Reference

Designing Service Functions

Migration Checklist

Anti-Patterns

Example: Email Service (Simple)

Mental Model

Files

Used in 2 other repositories

Compare with similar skills

Similar skills

More from vvedantb/eva

Related

Questions about Code Structure