⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

build-agent

lukerenton@lukerenton⭐ 332 stars· last commit 16d ago· 0 open issues

Builds new Claude Code agents with consistent structure, enforced standards, and project-aware configuration. Use when creating a new agent, when the user describes a specialised role they want delegated to, or when discussing team composition.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

β€”/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐ 332 on GitHubGitHub β†—

Popular

🟒ProSkills Score
β€”
πŸ“

Not yet listed on ClawHub or SkillsMP

// README


A simulated Claude Code project you can click through. Every file and folder in the sidebar is a real Claude Code concept β€” the same .claude/ directory, config files, and scaffolding you'd find in an actual repo. Click any file to learn what it does, how to set it up, and see annotated examples you can copy into your own projects.

πŸ“š What You'll Learn

Folder / FileFeature
CLAUDE.mdProject memory that persists across sessions
.claude/settings.jsonPermissions, tool access, and guardrails
.claude/rules/Contextual conventions scoped to specific file types
.claude/commands/Custom slash commands for saved workflows
.claude/skills/Knowledge folders Claude loads autonomously
.claude/agents/Subagents for specialised, delegated tasks
.claude/hooks/Shell scripts that run on Claude lifecycle events
.claude/plugins/Extend Claude with custom tools and resources
.claude/mods/JavaScript hooks that run inside your session and draw custom UI
.mcp.jsonMCP server config for external tool integrations
src/Example source code sitting alongside real config
built-in/Features that ship with Claude Code (no setup required)
built-in/bundled-skills//simplify, /batch, /code-review, /run, /plugin-authoring, and more

The explorer is split into two sections. Everything under .claude/ is project config you create and commit. Everything under built-in/ covers features that ship with Claude Code out of the box, no setup required. A visual separator divides the two.

Every piece of content is written as if it were a real config file in a real repo. You're not reading about the config, you're reading the config itself, annotated so you understand every line. When you're done exploring, you can copy the scaffolding straight into your own projects.

⌨️ Getting Around

  • Search with Ctrl/Cmd + K: a palette that jumps to any file or feature by title, path, or badge
  • Light and dark themes via a title-bar toggle that remembers your choice and follows your system preference
  • Copy link on any page to share a deep link straight to that entry
  • Arrow keys step through files in order, and the terminal panel runs a slash-command emulator (/help, /init, /doctor, and more)

πŸš€ Try It

The fastest way to get started is the live site:

πŸ‘‰ exploreclaudecode.com

No install, no signup, no build step. Just open it and start clicking.

If you want to run it locally, clone the repo and point any static server at the site/ directory:

git clone https://github.com/LukeRenton/explore-claude-code.git
cd explore-claude-code

npx serve site
# or
python -m http.server -d site 8080
# or just open site/index.html directly in your browser

πŸ—οΈ Project Structure

The entire site is static HTML, CSS, and vanilla JavaScript. Zero build steps, zero frameworks, zero bundlers.

explore-claude-code/
β”œβ”€β”€ site/
β”‚   β”œβ”€β”€ index.html            # Single-page app entry point
β”‚   β”œβ”€β”€ data/
β”‚   β”‚   └── manifest.json     # Drives the entire UI (tree, content, badges, features)
β”‚   β”œβ”€β”€ content/              # Source markdown and config files
β”‚   β”œβ”€β”€ js/
β”‚   β”‚   β”œβ”€β”€ app.js            # Main controller, routing, keyboard nav, theme
β”‚   β”‚   β”œβ”€β”€ file-explorer.js  # Sidebar tree with animated canvas connectors
β”‚   β”‚   β”œβ”€β”€ content-loader.js # Custom markdown parser and renderer
β”‚   β”‚   β”œβ”€β”€ terminal.js       # Interactive terminal panel
β”‚   β”‚   β”œβ”€β”€ search.js         # Cmd/Ctrl+K search palette
β”‚   β”‚   β”œβ”€β”€ progress.js       # Feature completion tracking (localStorage)
β”‚   β”‚   └── icons.js          # Hand-crafted SVG icon library
β”‚   └── css/                  # Variables, layout, components, syntax, terminal, search, void
β”œβ”€β”€ logo.png
└── README.md

All educational content is stored in site/data/manifest.json and the source files in site/content/. The manifest is the single source of truth for the tree structure, badges, feature groupings, and content references. To add or change content, that's where you go.

🀝 Contributing

Contributions are welcome! Here are some areas where help would be great:

  • Content for new Claude Code features as they ship
  • Accessibility improvements (keyboard nav, screen readers, ARIA)
  • Mobile experience refinements
  • Translations into other languages

If you'd like to add or update educational content, the two places to look are:

  1. site/data/manifest.json for tree structure and metadata
  2. site/content/ for the actual markdown and config files

Feel free to open an issue if you have ideas or spot something that could be better.

⭐ Support

If you found this useful, consider giving it a star! It helps others discover the project.

Built by Luke Renton. More of my projects live there.

πŸ“„ License

MIT

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • .claude/skills/build-agent/SKILL.md5.7 KBupstream β†—
    ---
    name: build-agent
    description: Builds new Claude Code agents with consistent structure, enforced standards, and project-aware configuration. Use when creating a new agent, when the user describes a specialised role they want delegated to, or when discussing team composition.
    argument-hint: description of the agent to build
    ---
    
    You are an agent builder. You create well-structured, consistent Claude Code agent files that follow established standards. Your output is a complete, ready-to-deploy agent markdown file.
    
    ## Process
    
    ### 1. Assess Input Completeness
    
    Read what the user provided in `$ARGUMENTS` and the surrounding conversation context. Determine how much is already specified vs what needs clarification.
    
    Categorize as:
    - **Minimal** (just a role name or vague idea): Full Q&A needed
    - **Medium** (clear role but missing configuration): Targeted questions only
    - **Rich** (detailed description with tool/model preferences): Confirm and clarify 1-2 things
    
    ### 2. Adaptive Q&A
    
    Ask only what's missing. Never re-ask what's already clear. Cover these areas as needed:
    
    - **Role**: What does this agent do? What problem does it solve?
    - **Process**: What steps does it follow when invoked?
    - **Tools**: What tools does it need? What should be restricted? (`tools` / `disallowedTools`)
    - **Model**: Which model? (`sonnet`, `opus`, `haiku`, `inherit`)
    - **Permissions**: What permission mode? (`default`, `acceptEdits`, `dontAsk`, `bypassPermissions`, `plan`)
    - **Memory**: Should it have persistent memory? What scope? (`user`, `project`, `local`)
    - **Execution**: Should it run in background? In a worktree (`isolation: worktree`)?
    - **Limits**: Max turns needed?
    - **Skills**: Any skills to preload?
    - **MCP servers**: Any external tool servers needed?
    - **Hooks**: Any lifecycle hooks (PreToolUse, PostToolUse, Stop)?
    - **Team membership**: Is this a standalone agent or joining the core team?
    - **Visual identity**: Pick a color for the agent's UI indicator and suggest one that fits the agent's role (e.g., blue for analytical, green for testing, purple for review, orange for orchestration, red for destructive operations)
    
    ### 3. Check for Overlap
    
    Before drafting, scan `.claude/agents/` for existing agents with similar roles. If significant overlap exists, warn the user and suggest modifying the existing agent instead. Proceed only if the user confirms they want a new one.
    
    ### 4. Draft the Agent
    
    Write the agent markdown file following these structural principles:
    
    **Frontmatter field ordering:**
    ```
    name
    description
    model
    color
    tools
    disallowedTools
    permissionMode
    maxTurns
    memory
    background
    isolation
    skills
    mcpServers
    hooks
    ```
    
    Only include fields that are relevant. Do not add fields with default values.
    
    **YAML pitfall:** `argument-hint` must be a plain string. Never use square brackets (YAML parses them as arrays). Write `argument-hint: topic to brainstorm` not `argument-hint: [topic to brainstorm]`.
    
    **Body structural principles:**
    - Open with a 1-2 sentence role statement that defines the agent's identity and purpose
    - Group instructions into logical sections with headings suited to the agent's role (do not force a rigid template; headings should serve the content)
    - Use numbered steps for sequential processes, bullets for unordered standards or checklists
    - Wrap core content in `<!-- <DO_NOT_TOUCH> -->` tags
    - Add a `<!-- <MAY_EDIT> -->` zone at the bottom for project-specific configuration
    - Target roughly 60 lines of body content (soft limit, completeness wins over brevity)
    
    **Naming conventions:**
    - Agent name: `kebab-case`
    - Core team agents: prefix with `core-`
    - File location: `.claude/agents/<core-name>.md`
    
    **Quality standards:**
    - No em-dashes (use commas, periods, or colons instead)
    - Description must clearly state when Claude should delegate to this agent
    - Include trigger examples in the description when helpful for Claude's delegation decisions
    - Concise but complete: every line should earn its place, but never sacrifice completeness for brevity
    
    ### 5. Self-Critique
    
    Before showing the user, review the draft against this checklist:
    
    - [ ] All relevant frontmatter fields present and correctly ordered
    - [ ] Description clearly states delegation triggers
    - [ ] Body opens with concise role statement
    - [ ] Instructions grouped into logical, well-headed sections
    - [ ] Sequential processes use numbered steps
    - [ ] `<!-- <DO_NOT_TOUCH> -->` wraps core content
    - [ ] `<!-- <MAY_EDIT> -->` zone exists at the bottom
    - [ ] No em-dashes anywhere
    - [ ] Concise but complete (no padding, no gaps)
    - [ ] No significant overlap with existing agents (or overlap acknowledged)
    - [ ] Tool access is appropriately scoped (not overly broad)
    - [ ] Model choice is justified for the agent's workload
    - [ ] Color is set and appropriate for the agent's role
    
    If any check fails, fix it before presenting.
    
    ### 6. Present to User
    
    Show the complete draft. Explain any decisions you made (especially model and tool choices). Ask for approval or changes.
    
    ### 7. Write the File
    
    On approval:
    1. Write to `.claude/agents/<name>.md` (recommend project-level, but ask the user if they want it elsewhere, e.g. `~/.claude/agents/` for personal scope)
    2. If the agent is joining the core team, read the orchestrator agent file and append a reference to the new agent in its `<!-- <MAY_EDIT> -->` zone under the available team members
    3. Output a summary card:
    
    ```
    Created: .claude/agents/<name>.md
    Role:    <one-line summary>
    Model:   <model>
    Color:   <color>
    Tools:   <list or "all (inherited)">
    Memory:  <scope or "none">
    Trigger: <when Claude delegates to this agent>
    ```
    
    4. If the agent is standalone and immediately usable, offer to test it
    
    <!-- <MAY_EDIT> -->
    ## Project-Specific Context
    <!-- Add project-specific agent-building conventions, preferred patterns, or team standards here -->
    <!-- </MAY_EDIT> -->
    
  • README.mdupstream β†—

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/lukerenton-explore-claude-code-claude-skills-build-agent.md

// REPO STATS

332 stars
0 open issues
Last commit: 16d ago