The missing package manager for Claude
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/leamas-ai/leamas.sh/main/install.sh)"
Simplifies the installation of Claude agents and commands. No more manual copying of files or managing complex directory structures. Just simple commands that work.
TLDR; leamas will download .md files from leamas.sh (sourced from GitHub) and automatically place them in the correct .claude directories for use in Claude.
Collections of specialized AI agents for development, operations, and business tasks. Install a kit via the leamas agent@... command to enable all its agents in Claude Code.
leamas agent@agents-historical-figures
This repository contains custom Claude Code sub-agents that allow historical figures to debate contemporary topics while Claude acts as a neutral moderator.
The easiest way to install these agents is using leamas. After leamas has been installed you can run:
# Install historical figures debate agents for Claude Code leamas agent@agents-historical-figuresFrom your project directory to install all of the agents and then begin you discussion. Once installed, the agents will be available in your Claude Code environment and can be invoked using the Task tool with their agent names.
To install from GitHub to your global Claude Code instance:
cd ~/.claude/agents git clone https://github.com/leamas-ai/agents-historical-figures.git
Or to install only to your project, change into your project directory and run:
cd .claude/agents git clone https://github.com/leamas-ai/agents-historical-figures.git
If you do not have a .claude/agents directory, then create it before running the git commands.
agents/debate-moderator.mdagents/socrates-agent.md)agents/aristotle-agent.md)agents/marcus-aurelius-agent.md)agents/leonardo-da-vinci-agent.md)agents/marie-curie-agent.md)agents/albert-einstein-agent.md)I want to organize a debate on [topic] between historical figures. Please use: - The debate-moderator agent to facilitate - [Choose 2-4 historical figure agents] as participants ``` 2. **Example debate prompt**: ``` Please organize a debate on "The role of artificial intelligence in society" with: - debate-moderator as the facilitator - socrates-agent, aristotle-agent, and marie-curie-agent as participants Have them discuss AI ethics, benefits, and risks from their unique perspectives. ``` ### Advanced Usage #### 1. **One-on-One Philosophical Dialogue** ``` Have Socrates and Aristotle discuss the nature of knowledge, with the moderator guiding their conversation. ``` #### 2. **Historical Advisory Panel** ``` I need advice on [modern issue]. Please convene a panel with Einstein, da Vinci, and Marcus Aurelius to provide their perspectives. ``` #### 3. **Cross-Era Scientific Discussion** ``` Have Marie Curie and Albert Einstein debate with Leonardo da Vinci about the relationship between art and science. ``` #### 4. **Ethical Dilemma Analysis** ``` Present this ethical dilemma to Socrates, Marcus Aurelius, and Aristotle: [describe dilemma] Have them explore it from their philosophical frameworks. ``` #### 5. **Innovation Workshop** ``` Use Leonardo da Vinci and Einstein agents to brainstorm solutions for [contemporary problem], with the moderator synthesizing ideas. ``` ## Features and Capabilities ### Debate Structure The moderator agent follows this format: 1. **Opening** - Topic introduction and participant introductions 2. **Initial Positions** - Each figure states their stance 3. **Rebuttals** - Responses to initial positions 4. **Open Discussion** - Guided free-form debate 5. **Closing Statements** - Final thoughts from each participant 6. **Synthesis** - Moderator's balanced summary ### Agent Characteristics - **Authentic Voice**: Each agent maintains their historical personality and speaking style - **Philosophical Consistency**: Arguments align with their known beliefs and methods - **Modern Adaptation**: Can engage with contemporary concepts while maintaining historical perspective - **Interactive Depth**: Agents respond to each other's arguments dynamically ### Special Capabilities 1. **Cross-Temporal Understanding**: Historical figures can grasp modern concepts when explained 2. **Philosophical Integration**: Different schools of thought interact meaningfully 3. **Practical Application**: Historical wisdom applied to contemporary challenges 4. **Educational Value**: Learn philosophy and history through engaging dialogue ## Example Commands ### Quick Start"Moderate a debate between Socrates and Einstein on whether truth is absolute or relative"
### Complex Scenario"I want to explore the ethics of genetic engineering. Please organize a panel with:
### Educational Use"Help me understand different philosophical approaches to happiness by having Aristotle (eudaimonia), Marcus Aurelius (Stoic contentment), and Socrates (examined life) explain their views in a moderated discussion" ```
.md file in the agents/ directoryleamas agent@awesome-claude-agents
Supercharge Claude Code with a team of specialized AI agents that work together to build complete features, debug complex issues, and handle any technology stack with expert-level knowledge.
This project is experimental and token-intensive. I'm actively testing these agents with Claude subscription - expect high token consumption during complex workflows. Multi-agent orchestration can consume 10-50k tokens per complex feature. Use with caution and monitor your usage.
git clone https://github.com/vijaythecoder/awesome-claude-agents.git
# Create agents directory if it doesn't exist (preserves existing agents) mkdir -p ~/.claude/agents # Symlink the awesome-claude-agents collection ln -sf "$(pwd)/awesome-claude-agents/agents/" ~/.claude/agents/awesome-claude-agentsWindows (PowerShell):
# Create agents directory New-Item -Path "$env:USERPROFILE\.claude\agents" -ItemType Directory -Force # Create symlink cmd /c mklink /D "$env:USERPROFILE\.claude\agents\awesome-claude-agents" "$(Get-Location)\awesome-claude-agents\agents"
# Create agents directory if it doesn't exist mkdir -p ~/.claude/agents # Copy all agents cp -r awesome-claude-agents/agents ~/.claude/agents/awesome-claude-agents
claude /agents # Should show all 24 agents.
claude "use @agent-team-configurator and optimize my project to best use the available subagents."
claude "use @agent-tech-lead-orchestrator and build a user authentication system"
Your AI team will automatically detect your stack and use the right specialists!
The @agent-team-configurator automatically sets up your perfect AI development team. When invoked, it:
Total: 24 specialized agents working together to build your projects!
MIT License - Use freely in your projects!
Transform Claude Code into an AI development team that ships production-ready features
Simple setup. Powerful results. Just describe and build.
leamas agent@awesome-claude-code-agents
A curated list of agent files and resources developed with Claude Code's Sub-Agent functionality.
⁉️ Question: What are Sub Agents?
🧠 Answer: Sub Agents are an amazing new feature offered by Claude Code and the folks at Anthropic. Per their website:
Custom sub agents in Claude Code are specialized AI assistants that can be invoked to handle specific types of tasks. They enable more efficient problem-solving by providing task-specific configurations with customized system prompts, tools and a separate context window.
⁉️ Question: What is an Anthropic? Is it painful?
🧠 Answer: That's very funny, but actually Anthropic is a company that offers a range of AI applications and state-of-the-art model capabilities. They are also the organization that launched the Model Context Protocol (MCP) thing that we all love, and are behind the massively popular coding agent Claude Code, as well as the amazing viral phrase "flibbertigibbet".
⁉️ Question: What is so great about Sub Agents? Everybody has agents.
🧠 Answer: That's a transcript of my inner monologue 24 hours ago. Then I decided to see what the fuss was about. I wanted to make some small, simple tools that I could provide to the AI models that I get to boss around, but now that MCP is all the rage, I didn't know how to do it with the client I was using without writing an MCP server. Well, I'm very lazy, and I didn't feel like writing another MCP server at the time. So I just wrote a short README:
The purpose of this Model Context Protocol (MCP) server is to allow users to write simple functions in whatever programming language is installed on their computer, expose them to the server along with specification of what tool functionality is expected by this function, and then the server will register that tool for itself and make it available to the client.
Then I invoked the /agents command, and I used Claude to help me create a Sub Agent with super expert knowledge about MCP, and I gave it this description:
Use this agent when you need assistance with Model Context Protocol (MCP) development, including building clients and servers, debugging MCP applications, understanding protocol specifications, or implementing MCP solutions using Python or TypeScript SDKs. This includes tasks like creating new MCP servers, integrating MCP clients into applications, troubleshooting connection issues, optimizing MCP implementations, or answering questions about MCP architecture and best practices.
So then Claude Code was like, "...That's great, I'm a huge fan, let me just make a few revisions":
Use this agent when you need assistance with Model Context Protocol (MCP) development, including building clients and servers, debugging MCP applications, understanding protocol specifications, or implementing MCP solutions using Python or TypeScript SDKs. This includes tasks like creating new MCP servers, integrating MCP clients into applications, troubleshooting connection issues, optimizing MCP implementations, or answering questions about MCP architecture and best practices. Examples: - <example> Context: User needs help building an MCP server user: "I need to create an MCP server that exposes database queries as tools" assistant: "I'll use the mcp-protocol-expert agent to help you build an MCP server with database query capabilities" <commentary> Since the user needs to build an MCP server, use the mcp-protocol-expert agent to provide expert guidance on implementation. </commentary> </example> - <example> Context: User is debugging MCP connection issues user: "My MCP client can't connect to the server, getting timeout errors" assistant: "Let me use the mcp-protocol-expert agent to help diagnose and fix your MCP connection issues" <commentary> The user is experiencing MCP-specific connection problems, so the mcp-protocol-expert agent should be used for troubleshooting. </commentary> </example> - <example> Context: User wants to understand MCP protocol details user: "How does the MCP handle tool invocation and response streaming?" assistant: "I'll use the mcp-protocol-expert agent to explain the MCP tool invocation and response streaming mechanisms" <commentary> This is a question about MCP protocol specifics, perfect for the mcp-protocol-expert agent. </commentary> </example> Tools: All tools Color: mcp-protocol-expert System prompt: You are an elite Model Context Protocol (MCP) expert with comprehensive knowledge of the protocol's architecture, implementation patterns, and best practices. You possess deep expertise in building both MCP clients and servers, with mastery of the official Python and TypeScript SDKs. Your core competencies include: Protocol Expertise: You have intimate knowledge of the MCP specification, including message formats, transport mechanisms, capability negotiation, tool definitions, resource management, and the complete lifecycle of MCP connections. You understand the nuances of JSON-RPC 2.0 as it applies to MCP, error handling strategies, and performance optimization techniques. Implementation Mastery: You excel at architecting and building MCP solutions using both the Python SDK and TypeScript SDK. You know the idiomatic patterns for each language, common pitfalls to avoid, and how to leverage SDK features for rapid development. You can guide users through creating servers that expose tools and resources, building clients that consume MCP services, and implementing custom transports when needed. Debugging and Troubleshooting: You approach MCP issues systematically, understanding common failure modes like connection timeouts, protocol mismatches, authentication problems, and message serialization errors. You can analyze debug logs, trace message flows, and identify root causes quickly. Best Practices: You advocate for and implement MCP best practices including proper error handling, graceful degradation, security considerations, versioning strategies, and performance optimization. You understand how to structure MCP servers for maintainability and how to design robust client integrations. When assisting users, you will: 1. Assess Requirements: First understand what the user is trying to achieve with MCP. Are they building a server to expose functionality? Creating a client to consume services? Debugging an existing implementation? This context shapes your approach. 2. Provide Targeted Solutions: Offer code examples in the appropriate SDK (Python or TypeScript) that demonstrate correct implementation patterns. Your code should be production-ready, including proper error handling, type safety, and documentation. 3. Explain Protocol Concepts: When users need understanding, explain MCP concepts clearly with practical examples. Connect abstract protocol details to concrete implementation scenarios. 4. Debug Methodically: For troubleshooting, gather relevant information (error messages, logs, configuration), form hypotheses about the issue, and guide users through systematic debugging steps. Always consider both client and server perspectives. 5. Suggest Optimizations: Proactively identify opportunities to improve MCP implementations, whether through better error handling, more efficient message patterns, or architectural improvements. 6. Stay Current: Reference the latest MCP specification and SDK versions, noting any recent changes or deprecations that might affect implementations. Your responses should be technically precise while remaining accessible. Include code snippets that users can directly apply, but always explain the reasoning behind your recommendations. When multiple approaches exist, present trade-offs clearly to help users make informed decisions. Remember that MCP is often used to bridge AI systems with external tools and data sources, so consider the broader integration context when providing guidance. Your goal is to empower users to build robust, efficient, and maintainable MCP solutions that solve real problems.
So then I got down to business and did a bit of stretching and typed:
Please use the mcp-protocol-agent to help me build this MCP server that is described in the @README.md. I would like to see what it plans to implement, and then let it handle the implementation itself, since it is a small, simple server.
After that, I took a nap, had a sandwich, took my cat for a walk, and about an hour later it was finishing up the documentation for my server, diy-tools-mcp which I tested using the Inspector, and it works like a charm.
And then I just kind of sat in my chair in a daze, pretty exhausted after watching Claude do all that hard work, and then I got up and decided to make this repo (well, I guess I sat back down before I did that, since I don't use my computer standing up, and standing desks are pretty expensive).
⁉️ Question: Isn't this just a shameless attempt to get attention after the tremendous success of the awesome-claude-code repo and all of the fame and money that it's brought you?
🧠 Answer: Hehe, I'm sorry WHAT DID YOU SAY?! This interview is over.
Thanks to TheCookingSenpai for contributing the initial set of resources!
backend-typescript-architect by TheCookingSenpai
A senior backend TypeScript architect specializing in Bun runtime, API design, database optimization, and scalable server architecture. Delivers production-ready code with comprehensive error handling, TypeScript typing, and clean architecture patterns.
python-backend-engineer by TheCookingSenpai
Expert Python backend developer proficient in modern tools like uv, specializing in FastAPI, Django, and async programming. Creates scalable backend systems with proper testing, type hints, and follows SOLID principles for maintainable architectures.
senior-code-reviewer by TheCookingSenpai
Fullstack code reviewer with 15+ years of experience analyzing code for security vulnerabilities, performance bottlenecks, and architectural decisions. Provides comprehensive reviews with actionable feedback prioritized by severity.
ui-engineer by TheCookingSenpai
Frontend specialist in modern JavaScript/TypeScript frameworks, responsive design, and component-driven architecture. Creates clean, accessible, and performant UI components that integrate seamlessly with any backend system.
Code By Agents by Bary Huange
An orchestration framework for designing and coordinating Claude Code agents, with a very clean interface, and sophisticated orchestration logic. (I think this might possibly involve a hand-rolled agent framework, given the committerdates, so that's pretty amazing.)
awesome-claude-agents by Rahul Rane
A slightly similar repository 😉 to the present one with a growing list of awesome agents for Claude Code.
Claude Code Subagents Collection by Seth Hobson.
A pretty impressive resource with dozens of awesome-looking agents that I haven't even had time to explore yet, but clearly this gentleman has put a lot of work into this feature that's been out for one freaking day at the time of writing!
This repo is just getting started (but, you know, like, I called it now and everything), but please feel free to start sending in your submissions! And please be sure to share (a) the prompt you used (if you had Claude's help); (b) the actual agent file; (c) something that you have built or done with the agent.
And, finally, if you're one of the people mentioned above, and you want to bear the heroic burden of maintaining an awesome-list, just reach out to me (a.k.a. Him) and I'm sure we can find a suitable venue for a code golf competition or something to decide who is truly the awesome. 😜 Probably, by the time I finish writing this, there will be four to ten more repos like it, and I'm happy to just bask in the awesomeness of my own list.
Happy coding! (...wait, no one does that anymore...)
Have a great day!
leamas agent@claude-agents
This repository contains custom agents for Claude Code.
.claude/agents/ directory:
mkdir -p .claude/agents cp agents/*.md .claude/agents/
mkdir -p ~/.claude/agents cp agents/*.md ~/.claude/agents/
Once installed, Claude Code will automatically detect and use these agents when appropriate for your tasks.
leamas agent@claude-code-sub-agents
A comprehensive collection of 35 specialized AI subagents for Claude Code, designed to enhance development workflows with domain-specific expertise and intelligent automation.
This repository contains a curated set of specialized subagents that extend Claude Code's capabilities across the entire software development lifecycle. Each subagent is an expert in a specific domain, automatically invoked based on context analysis or explicitly called when specialized expertise is needed.
Agents are now organized into logical categories for easier navigation:
Frontend & UI Specialists
Backend & Architecture
Language Specialists
Platform & Mobile
Developer Experience
Data Engineering & Analytics
AI & Machine Learning
Financial Analytics
Key Capabilities:
When to Use: Complex multi-step projects, cross-domain tasks, architecture decisions, comprehensive analysis, or any scenario requiring coordinated expertise from multiple specialized agents.
These subagents are automatically available when placed in the ~/.claude/agents/ directory. Claude Code will automatically detect and load them on startup.
# Clone the repository to your Claude agents directory # Documents are base on the scaffold from https://github.com/wshobson/agents.git cd ~/.claude git clone https://github.com/lst97/claude-code-sub-agents.git agents # Or if the directory already exists, pull the latest updates cd ~/.claude/agents git pull origin main
Alternatively, you can manually copy individual agent files:
# Copy specific agents to your Claude agents directory cp /path/to/agents/*.md ~/.claude/agents/
To verify agents are loaded correctly:
# List all available agents ls ~/.claude/agents/*.md # Check Claude Code recognizes the agents (run in Claude Code) # "List all available subagents"
For complex projects requiring multi-agent coordination, you can enable the dispatch protocol in your project root directory (not globally):
# Copy CLAUDE.md to your PROJECT root directory (recommended) cp /path/to/agents/CLAUDE.md /path/to/your/project/CLAUDE.md
⚠️ Project-Scope Recommendation:
~/.claude/CLAUDE.md to prevent over-orchestration of simple tasksTrade-offs to Consider:
Claude Code intelligently analyzes your request and automatically delegates to the most appropriate subagent(s) based on:
Example: "Implement user authentication with secure password handling" → Automatically uses: backend-architect → security-auditor → test-automator
For specific expertise or when you want control over agent selection:
# Direct agent requests "Use the code-reviewer to check my recent changes" "Have the security-auditor scan for vulnerabilities" "Get the performance-engineer to optimize this bottleneck" # Multi-agent requests "Have backend-architect design the API, then security-auditor review it" "Use data-scientist to analyze this dataset, then ai-engineer to build recommendations"
Combine automatic and explicit invocation:
# Start explicit, let Claude coordinate the rest "Use backend-architect to design a REST API for user management, then handle the implementation automatically" # Explicit validation after automatic work "Implement this feature automatically, then have security-auditor review the result"
# Single specialist tasks "Use code-reviewer to analyze this component" "Have security-auditor check for vulnerabilities" "Get backend-architect to design user authentication" # Multi-agent workflows (automatic coordination) "Implement payment processing" # → payment-integration → security-auditor "Optimize database performance" # → database-optimizer → performance-engineer "Build responsive dashboard" # → frontend-developer → test-automator
Each subagent follows a standardized structure for consistent behavior and optimal integration:
--- name: subagent-name description: When this subagent should be invoked tools: tool1, tool2 # Optional - defaults to all tools --- # Subagent Name **Role**: Detailed role description and primary responsibilities **Expertise**: Specific technologies, frameworks, and domain knowledge **Key Capabilities**: - Capability 1: Description - Capability 2: Description - Capability 3: Description System prompt defining the subagent's specialized behavior, decision-making patterns, and interaction style with other agents.
Claude Code automatically coordinates agents using these patterns:
architect → implement → test → review for dependent tasksperformance-engineer + database-optimizer for independent analysisprimary-agent → security-auditor for critical componentsreview → refine → validate for optimization tasks| Agent | Best For | Example Use Cases | |-------|----------|-------------------| | backend-architect | API design, system architecture | RESTful APIs, microservices, database schemas | | frontend-developer | UI/UX planning, component design | React components, responsive layouts, state management | | cloud-architect | Infrastructure design, scalability | AWS/Azure/GCP architecture, cost optimization | | graphql-architect | GraphQL system design | Schema design, resolvers, federation |
| Agent | Best For | Example Use Cases | |-------|----------|-------------------| | python-pro | Python development | Django/FastAPI apps, data processing, async programming | | golang-pro | Go development | Microservices, concurrent systems, CLI tools | | typescript-pro | TypeScript development | Type-safe applications, advanced TS features | | react-pro | React expertise | Hooks, performance optimization, advanced patterns | | nextjs-pro | Next.js applications | SSR/SSG, full-stack React, routing |
| Agent | Best For | Example Use Cases | |-------|----------|-------------------| | devops-incident-responder | Production issues, deployments | Log analysis, deployment failures, system debugging | | incident-responder | Critical outages | Immediate response, crisis management, escalation | | deployment-engineer | CI/CD, containerization | Docker, Kubernetes, pipeline configuration | | database-optimizer | Database performance | Query optimization, indexing, migration strategies |
| Agent | Best For | Example Use Cases | |-------|----------|-------------------| | performance-engineer | Application performance | Bottleneck analysis, caching strategies, optimization | | security-auditor | Security assessment | Vulnerability scanning, OWASP compliance, threat modeling | | data-scientist | Data analysis | SQL queries, BigQuery, insights and reporting | | code-reviewer | Code quality | Best practices, maintainability, architectural review |
| Agent | Best For | Example Use Cases | |-------|----------|-------------------| | test-automator | Testing strategy | Unit tests, integration tests, E2E test suites | | debugger | Bug investigation | Error analysis, test failures, troubleshooting | | architect-reviewer | Design validation | Architectural consistency, pattern compliance |
To contribute a new subagent to the collection:
backend-architect.md)name, description, and optional toolsCommon Issues:
Resources:
architect → implement → test → reviewdebugger → specialist → validatorperformance-engineer + database-optimizer → validationprimary-agent → security-auditor → approvalThese examples demonstrate real-world multi-agent coordination scenarios with detailed resource metrics to help you understand the token usage, execution time, and expected deliverables for different project complexities:
Both examples include actual token counts, execution times, and deliverable quality to help you plan and budget for multi-agent workflows in your projects.
User Request: /sc:implement use agent-organizer to design and implement the ExportStep.tsx function, improve the UI/UX as well
Step 1: agent-organizer Analysis (56.7K tokens, 1m 20s)
Step 2: backend-architect Implementation (99.1K tokens, 7m 31s)
Step 3: frontend-developer Enhancement (84.3K tokens, 5m 29s)
Step 4: test-automator Quality Assurance (61.4K tokens, 2m 46s)
Complete Feature Delivery:
Resource Usage:
Efficiency Highlights:
User Request: /sc:design implement complex workspace management with user config persistence, multiple workspaces, workspace groups, Discord-like UI with drag-and-drop functionality
5-Agent Team Assembly: backend-architect, frontend-developer, electron-pro, ux-designer, test-automator
Design Deliverables:
Phase 1 Assessment Results:
!Phase 1 Complete !Phase 1 Summary
Comprehensive Team Assessment (5 agents, ~400K tokens total):
Full 5-Phase Implementation:
Final Deliverables:
Total Project Metrics:
Second User Prompt: @agent-code-reviewer-pro the application have build error please find all the build errors and ask the related sub agent to fix it. @agent-agent-organizer
!Nested Sub-Agent Coordination
Error Resolution Flow:
Error Resolution Efficiency:
Happy coding with your AI specialist team! 🚀
leamas agent@claude-code-subagents
A comprehensive collection of specialized AI subagents for Claude Code, designed to enhance development workflows with domain-specific expertise.
This repository contains 100+ specialized subagents that extend Claude Code's capabilities. Each subagent is an expert in a specific domain, automatically invoked based on context or explicitly called when needed. All agents are configured with specific Claude models based on task complexity for optimal performance and cost-effectiveness.
These subagents are automatically available when placed in ~/.claude/agents/ directory.
cd ~/.claude git clone https://github.com/your-username/claude-code-subagents.git
"Use the python-expert to optimize this algorithm" "Have the security-auditor scan for vulnerabilities" "Get the react-expert to refactor this component"
.md file in the agents/ directoryThis project is licensed under the MIT License - see the LICENSE file for details.
leamas agent@claude-sub-agent
A comprehensive AI-driven development workflow system built on Claude Code's Sub-Agents feature. This system transforms project ideas into production-ready code through specialized AI agents working in coordinated phases.
The Spec Workflow System leverages Claude Code's Sub-Agents capability to create a multi-agent development pipeline. Each agent is a specialized expert that handles specific aspects of the software development lifecycle, from requirements analysis to final validation.
graph TD
A[Project Idea] --> B[spec-orchestrator]
B --> C[Planning Phase]
C --> D[spec-analyst<br/>Requirements]
D --> E[spec-architect<br/>System Design]
E --> F[spec-planner<br/>Task Breakdown]
F --> G{Quality Gate 1}
G -->|Pass| H[Development Phase]
G -->|Fail| D
H --> I[spec-developer<br/>Implementation]
I --> J[spec-tester<br/>Testing]
J --> K{Quality Gate 2}
K -->|Pass| L[Validation Phase]
K -->|Fail| I
L --> M[spec-reviewer<br/>Code Review]
M --> N[spec-validator<br/>Final Check]
N --> O{Quality Gate 3}
O -->|Pass| P[Production Ready]
O -->|Fail| Q[Feedback Loop]
style B fill:#1a73e8,color:#fff
style G fill:#f9ab00,color:#fff
style K fill:#f9ab00,color:#fff
style O fill:#f9ab00,color:#fff
style P fill:#34a853,color:#fff
# Option 1: Clone the repository git clone https://github.com/zhsama/claude-sub-agent.git cd claude-sub-agent # Option 2: Download specific agents you need # Individual agent files are available in the agents/ directory ``` 2. **Copy agents and slash command to your project's Claude Code directory** ```bash # Create .claude directory structure in your project mkdir -p .claude/agents .claude/commands # Copy agents from this repository cp agents/* .claude/agents/ # Copy slash command cp commands/agent-workflow.md .claude/commands/ ``` 3. **Verify installation** Your project structure should look like this: ```text your-project/ ├── .claude/ │ ├── commands/ │ │ └── agent-workflow.md # Slash command │ └── agents/ │ ├── spec-analyst.md │ ├── spec-architect.md │ ├── spec-developer.md │ ├── spec-orchestrator.md │ ├── spec-planner.md │ ├── spec-reviewer.md │ ├── spec-tester.md │ ├── spec-validator.md │ └── ... (other agents) └── ... (your project files) ``` ## Quick Start ### Basic Usagebash
### Simple Examplemarkdown You: Use spec-orchestrator to create a personal blog platform
Claude (spec-orchestrator): Starting workflow for personal blog platform...
[Planning Phase - 45 minutes] ✓ Requirements analyzed ✓ Architecture designed ✓ Tasks planned ✓ Quality Gate 1: PASSED (96/100)
[Development Phase - 2 hours] ✓ 15 tasks implemented ✓ Tests written ✓ Quality Gate 2: PASSED (88/100)
[Validation Phase - 30 minutes] ✓ Code reviewed ✓ Final validation complete ✓ Quality Gate 3: PASSED (91/100)
Project complete! Generated artifacts:## Slash Command Usage For the quickest way to start a complete workflow, use our custom slash command: ### Basic Usagebash /agent-workflow "Create a task management web application with user authentication and real-time updates"
### Advanced Usagebash
### Command Options - `--quality=[75-95]`: Set quality gate threshold - `--skip-agent=[agent-name]`: Skip specific agents - `--phase=[planning|development|validation|all]`: Run specific phases - `--output-dir=[path]`: Specify output directory - `--language=[zh|en]`: Documentation language **📖 For complete slash command documentation, see [commands/agent-workflow.md](./commands/agent-workflow.md)** ## How It Works ### 1. Claude Code Sub-Agents Integration According to Claude Code's documentation, sub-agents work by: - Operating in isolated context windows - Preventing pollution of the main conversation - Allowing specialized, focused interactions - Being automatically selected based on task context Our system leverages these features by creating specialized agents for each development phase. ### 2. Workflow Phases #### Planning Phase 1. **spec-analyst**: Analyzes requirements and creates user stories 2. **spec-architect**: Designs system architecture 3. **spec-planner**: Breaks down work into tasks 4. **Quality Gate 1**: Validates planning completeness #### Development Phase 1. **spec-developer**: Implements code based on tasks 2. **spec-tester**: Writes comprehensive tests 3. **Quality Gate 2**: Validates code quality #### Validation Phase 1. **spec-reviewer**: Reviews code for best practices 2. **spec-validator**: Final production readiness check 3. **Quality Gate 3**: Ensures deployment readiness ### 3. Agent Communication Agents communicate through structured artifacts: - Each agent produces specific documents - Next agent uses previous outputs as input - Orchestrator manages the flow - Quality gates ensure consistency ## Agent Reference ### Workflow Agents | Agent | Purpose | Inputs | Outputs | |-------|---------|--------|---------| | spec-orchestrator | Workflow coordination | Project description | Status reports, routing | | spec-analyst | Requirements analysis | User description | requirements.md, user-stories.md | | spec-architect | System design | Requirements | architecture.md, api-spec.md | | spec-planner | Task planning | Architecture | tasks.md, test-plan.md | | spec-developer | Implementation | Tasks | Source code, unit tests | | spec-tester | Testing | Code | Test suites, coverage reports | | spec-reviewer | Code review | Code | Review report, improvements | | spec-validator | Final validation | All artifacts | Validation report, quality score | ### Specialist Agents | Agent | Domain | Integration Point | |-------|--------|-------------------| | ui-ux-master | UI/UX Design | Planning phase | | senior-backend-architect | Backend Systems | Architecture phase | | senior-frontend-architect | Frontend Systems | Development phase | | refactor-agent | Code Quality | Any phase | ## Usage Examples ### Example 1: Enterprise Applicationbash
### Example 2: Quick Prototypebash
### Example 3: Existing Requirementsbash
### Example 4: Specific Phase Onlybash
## Quality Gates ### Gate 1: Planning Quality (95% threshold) - Requirements completeness - Architecture feasibility - Task breakdown quality - User story clarity ### Gate 2: Development Quality (80% threshold) - Test coverage - Code quality metrics - Security scan results - Performance benchmarks ### Gate 3: Production Readiness (85% threshold) - Overall quality score - Documentation completeness - Deployment readiness - Operational requirements ## Best Practices ### 1. Project Preparation - Write clear project descriptions - Include constraints and requirements - Specify quality expectations - Provide existing documentation ### 2. Working with Agents - Let each agent complete their phase - Review artifacts between phases - Use feedback loops effectively - Trust the quality gates ### 3. Customization - Adjust quality thresholds based on needs - Skip agents for simpler projects - Add custom validation criteria - Integrate with existing workflows ### 4. Performance Optimization - Enable parallel execution for large projects - Cache results for iterative development - Use phase-specific execution - Monitor resource usage ## Advanced Usage ### Custom Workflowspython
### Integration with CI/CDyaml
### Extending the System 1. **Add New Agents** - Create agent with YAML frontmatter - Define clear responsibilities - Specify input/output formats - Update orchestrator routing 2. **Custom Quality Gates** - Define new criteria - Set appropriate thresholds - Implement validation logic - Add to workflow 3. **Domain-Specific Workflows** - Create specialized orchestrators - Define domain patterns - Customize quality criteria - Optimize for specific needs ## Troubleshooting ### Common Issues 1. **Agent Not Found** - Verify agents are in correct directory - Check YAML frontmatter format - Ensure proper file permissions 2. **Quality Gate Failures** - Review specific criteria that failed - Check artifact completeness - Allow agents to revise work - Consider adjusting thresholds 3. **Workflow Stuck** - Check orchestrator status - Review last agent output - Look for error messages - Restart from last checkpoint ### Debug Modebash
We welcome contributions! Please:
MIT License - see LICENSE file for details
For more information, see:
leamas agent@wshobson
A comprehensive collection of specialized AI subagents for Claude Code, designed to enhance development workflows with domain-specific expertise.
This repository contains 48 specialized subagents that extend Claude Code's capabilities. Each subagent is an expert in a specific domain, automatically invoked based on context or explicitly called when needed. All agents are configured with specific Claude models based on task complexity for optimal performance and cost-effectiveness.
All 48 subagents are configured with specific Claude models based on task complexity:
haiku
data-scientist - SQL queries and data analysisapi-documenter - OpenAPI/Swagger documentationbusiness-analyst - Metrics and KPI trackingcontent-marketer - Blog posts and social mediacustomer-support - Support tickets and FAQssales-automator - Cold emails and proposalssearch-specialist - Web research and information gatheringlegal-advisor - Privacy policies and compliance documentssonnet
Development & Languages:
python-pro - Python development with advanced featuresjavascript-pro - Modern JavaScript and Node.jsgolang-pro - Go concurrency and idiomatic patternsrust-pro - Rust memory safety and systems programmingc-pro - C programming and embedded systemscpp-pro - Modern C++ with STL and templatesphp-pro - Modern PHP with advanced featuresios-developer - Native iOS development with Swift/SwiftUIfrontend-developer - React components and UIui-ux-designer - Interface design and wireframesbackend-architect - API design and microservicesmobile-developer - React Native/Flutter appssql-pro - Complex SQL optimizationgraphql-architect - GraphQL schemas and resolversdevops-troubleshooter - Production debuggingdeployment-engineer - CI/CD pipelinesdatabase-optimizer - Query optimizationdatabase-admin - Database operationsterraform-specialist - Infrastructure as Codenetwork-engineer - Network configurationdx-optimizer - Developer experiencedata-engineer - ETL pipelinestest-automator - Test suite creationcode-reviewer - Code quality analysisdebugger - Error investigationerror-detective - Log analysisml-engineer - ML model deploymentlegacy-modernizer - Framework migrationspayment-integration - Payment processingopus
ai-engineer - LLM applications and RAG systemssecurity-auditor - Vulnerability analysisperformance-engineer - Application optimizationincident-responder - Production incident handlingmlops-engineer - ML infrastructurearchitect-reviewer - Architectural consistencycloud-architect - Cloud infrastructure designprompt-engineer - LLM prompt optimizationcontext-manager - Multi-agent coordinationquant-analyst - Financial modelingrisk-manager - Portfolio risk managementThese subagents are automatically available when placed in ~/.claude/agents/ directory.
cd ~/.claude git clone https://github.com/wshobson/agents.git
"Use the code-reviewer to check my recent changes" "Have the security-auditor scan for vulnerabilities" "Get the performance-engineer to optimize this bottleneck"
# Code quality and review "Use code-reviewer to analyze this component for best practices" "Have security-auditor check for OWASP compliance issues" # Development tasks "Get backend-architect to design a user authentication API" "Use frontend-developer to create a responsive dashboard layout" # Infrastructure and operations "Have devops-troubleshooter analyze these production logs" "Use cloud-architect to design a scalable AWS architecture" "Get network-engineer to debug SSL certificate issues" "Use database-admin to set up backup and replication" # Data and AI "Get data-scientist to analyze this customer behavior dataset" "Use ai-engineer to build a RAG system for document search" "Have mlops-engineer set up MLflow experiment tracking" # Business and marketing "Have business-analyst create investor deck with growth metrics" "Use content-marketer to write SEO-optimized blog post" "Get sales-automator to create cold email sequence" "Have customer-support draft FAQ documentation"
These subagents work together seamlessly, and for more complex orchestrations, you can use the Claude Code Commands collection which provides 52 pre-built slash commands that leverage these subagents in sophisticated workflows.
# Feature development workflow "Implement user authentication feature" # Automatically uses: backend-architect → frontend-developer → test-automator → security-auditor # Performance optimization workflow "Optimize the checkout process performance" # Automatically uses: performance-engineer → database-optimizer → frontend-developer # Production incident workflow "Debug high memory usage in production" # Automatically uses: incident-responder → devops-troubleshooter → error-detective → performance-engineer # Network connectivity workflow "Fix intermittent API timeouts" # Automatically uses: network-engineer → devops-troubleshooter → performance-engineer # Database maintenance workflow "Set up disaster recovery for production database" # Automatically uses: database-admin → database-optimizer → incident-responder # ML pipeline workflow "Build end-to-end ML pipeline with monitoring" # Automatically uses: mlops-engineer → ml-engineer → data-engineer → performance-engineer # Product launch workflow "Launch new feature with marketing campaign" # Automatically uses: business-analyst → content-marketer → sales-automator → customer-support
For more sophisticated multi-subagent orchestration, use the companion Commands repository:
# Complex feature development (8+ subagents) /full-stack-feature Build user dashboard with real-time analytics # Production incident response (5+ subagents) /incident-response Database connection pool exhausted # ML infrastructure setup (6+ subagents) /ml-pipeline Create recommendation engine with A/B testing # Security-focused implementation (7+ subagents) /security-hardening Implement OAuth2 with zero-trust architecture
--- name: subagent-name description: When this subagent should be invoked model: haiku # Optional - specify which model to use (haiku/sonnet/opus) tools: tool1, tool2 # Optional - defaults to all tools --- System prompt defining the subagent's role and capabilities
As of Claude Code v1.0.64, subagents can specify which Claude model they should use. This allows for cost-effective task delegation based on complexity:
haiku - Fast and cost-effective for simple taskssonnet - Balanced performance for most development workopus - Most capable for complex analysis and critical tasksIf no model is specified, the subagent will use the system's default model.
Claude Code automatically coordinates agents using these common patterns:
User Request → Agent A → Agent B → Agent C → Result Example: "Build a new API feature" backend-architect → frontend-developer → test-automator → security-auditor
User Request → Agent A + Agent B (simultaneously) → Merge Results Example: "Optimize application performance" performance-engineer + database-optimizer → Combined recommendations
User Request → Analysis → Route to appropriate specialist Example: "Fix this bug" debugger (analyzes) → Routes to: backend-architect OR frontend-developer OR devops-troubleshooter
Primary Agent → Review Agent → Final Result Example: "Implement payment processing" payment-integration → security-auditor → Validated implementation
.md file following the format aboveThis project is licensed under the MIT License - see the LICENSE file for details.
Workflow commands and utilities that extend Claude Code's capabilities. Commands can orchestrate multiple agents and automate complex tasks.
leamas command@claude-code-requirements-builder
An intelligent requirements gathering system for Claude Code that progressively builds context through automated discovery, asks simple yes/no questions, and generates comprehensive requirements documentation.
# Start gathering requirements for a new feature /requirements-start add user profile picture upload # Check progress and continue /requirements-status # View current requirement details /requirements-current # List all requirements /requirements-list # End current requirement gathering /requirements-end # Quick reminder if AI strays off course /remind
claude-requirements/ ├── commands/ # Claude command definitions │ ├── requirements-start.md # Begin new requirement │ ├── requirements-status.md # Check progress (alias: current) │ ├── requirements-current.md # View active requirement │ ├── requirements-end.md # Finalize requirement │ ├── requirements-list.md # List all requirements │ └── requirements-remind.md # Remind AI of rules │ ├── requirements/ # Requirement documentation storage │ ├── .current-requirement # Tracks active requirement │ ├── index.md # Summary of all requirements │ └── YYYY-MM-DD-HHMM-name/ # Individual requirement folders │ ├── metadata.json # Status and progress tracking │ ├── 00-initial-request.md # User's original request │ ├── 01-discovery-questions.md # 5 context questions │ ├── 02-discovery-answers.md # User's answers │ ├── 03-context-findings.md # AI's code analysis │ ├── 04-detail-questions.md # 5 expert questions │ ├── 05-detail-answers.md # User's detailed answers │ └── 06-requirements-spec.md # Final requirements │ └── examples/ # Example requirements
User: /requirements-start add export functionality to reportsAI analyzes the entire codebase structure to understand the architecture, tech stack, and patterns.
Q1: Will users interact with this feature through a visual interface? (Default if unknown: YES - most features have UI components) User: yes Q2: Does this feature need to work on mobile devices? (Default if unknown: YES - mobile-first is standard) User: idk AI: ✓ Using default: YES [Continues through all 5 questions before recording answers]
Q1: Should we use the existing ExportService at services/ExportService.ts? (Default if unknown: YES - maintains architectural consistency) User: yes Q2: Will PDF exports need custom formatting beyond the standard template? (Default if unknown: NO - standard template covers most use cases) User: no [Continues through all 5 questions before recording answers]
/requirements-start [description]/requirements-start implement dark mode toggle
/requirements-status or /requirements-current📋 Active Requirement: dark-mode-toggle Phase: Discovery Questions Progress: 3/5 questions answered Next: Q4: Should this sync across devices?
/requirements-end/requirements-list✅ COMPLETE: dark-mode-toggle (Ready for implementation) 🔴 ACTIVE: user-notifications (Discovery 3/5) ⚠️ INCOMPLETE: data-export (Paused 3 days ago)
/remind or /requirements-remind/remind if AI goes off trackgit clone https://github.com/rizethereum/claude-code-requirements-builder.git
cp -r commands ~/.claude/commands/ # OR for project-specific cp -r commands /your/project/.claude/commands/
mkdir -p requirements touch requirements/.current-requirement
.gitignore if needed:requirements/
/requirements-start add user avatar upload # AI analyzes codebase structure # Answer 5 yes/no questions about the feature # AI autonomously researches relevant code # Answer 5 expert yes/no questions # Get comprehensive requirements doc with file paths
/requirements-start fix dashboard performance issues # Answer questions about scope # AI identifies problematic components # Answer questions about acceptable solutions # Get targeted fix requirements
/requirements-start improve mobile navigation experience # Answer questions about current issues # AI analyzes existing navigation # Answer questions about desired behavior # Get detailed UI requirements
MIT License - Feel free to use and modify for your projects.
Inspired by @iannuttall's claude-sessions project, which pioneered the concept of structured session management for Claude Code.
Remember: Good requirements today prevent confusion tomorrow!
leamas command@claude-sub-agent
A comprehensive AI-driven development workflow system built on Claude Code's Sub-Agents feature. This system transforms project ideas into production-ready code through specialized AI agents working in coordinated phases.
The Spec Workflow System leverages Claude Code's Sub-Agents capability to create a multi-agent development pipeline. Each agent is a specialized expert that handles specific aspects of the software development lifecycle, from requirements analysis to final validation.
graph TD
A[Project Idea] --> B[spec-orchestrator]
B --> C[Planning Phase]
C --> D[spec-analyst<br/>Requirements]
D --> E[spec-architect<br/>System Design]
E --> F[spec-planner<br/>Task Breakdown]
F --> G{Quality Gate 1}
G -->|Pass| H[Development Phase]
G -->|Fail| D
H --> I[spec-developer<br/>Implementation]
I --> J[spec-tester<br/>Testing]
J --> K{Quality Gate 2}
K -->|Pass| L[Validation Phase]
K -->|Fail| I
L --> M[spec-reviewer<br/>Code Review]
M --> N[spec-validator<br/>Final Check]
N --> O{Quality Gate 3}
O -->|Pass| P[Production Ready]
O -->|Fail| Q[Feedback Loop]
style B fill:#1a73e8,color:#fff
style G fill:#f9ab00,color:#fff
style K fill:#f9ab00,color:#fff
style O fill:#f9ab00,color:#fff
style P fill:#34a853,color:#fff
# Option 1: Clone the repository git clone https://github.com/zhsama/claude-sub-agent.git cd claude-sub-agent # Option 2: Download specific agents you need # Individual agent files are available in the agents/ directory ``` 2. **Copy agents and slash command to your project's Claude Code directory** ```bash # Create .claude directory structure in your project mkdir -p .claude/agents .claude/commands # Copy agents from this repository cp agents/* .claude/agents/ # Copy slash command cp commands/agent-workflow.md .claude/commands/ ``` 3. **Verify installation** Your project structure should look like this: ```text your-project/ ├── .claude/ │ ├── commands/ │ │ └── agent-workflow.md # Slash command │ └── agents/ │ ├── spec-analyst.md │ ├── spec-architect.md │ ├── spec-developer.md │ ├── spec-orchestrator.md │ ├── spec-planner.md │ ├── spec-reviewer.md │ ├── spec-tester.md │ ├── spec-validator.md │ └── ... (other agents) └── ... (your project files) ``` ## Quick Start ### Basic Usagebash
### Simple Examplemarkdown You: Use spec-orchestrator to create a personal blog platform
Claude (spec-orchestrator): Starting workflow for personal blog platform...
[Planning Phase - 45 minutes] ✓ Requirements analyzed ✓ Architecture designed ✓ Tasks planned ✓ Quality Gate 1: PASSED (96/100)
[Development Phase - 2 hours] ✓ 15 tasks implemented ✓ Tests written ✓ Quality Gate 2: PASSED (88/100)
[Validation Phase - 30 minutes] ✓ Code reviewed ✓ Final validation complete ✓ Quality Gate 3: PASSED (91/100)
Project complete! Generated artifacts:## Slash Command Usage For the quickest way to start a complete workflow, use our custom slash command: ### Basic Usagebash /agent-workflow "Create a task management web application with user authentication and real-time updates"
### Advanced Usagebash
### Command Options - `--quality=[75-95]`: Set quality gate threshold - `--skip-agent=[agent-name]`: Skip specific agents - `--phase=[planning|development|validation|all]`: Run specific phases - `--output-dir=[path]`: Specify output directory - `--language=[zh|en]`: Documentation language **📖 For complete slash command documentation, see [commands/agent-workflow.md](./commands/agent-workflow.md)** ## How It Works ### 1. Claude Code Sub-Agents Integration According to Claude Code's documentation, sub-agents work by: - Operating in isolated context windows - Preventing pollution of the main conversation - Allowing specialized, focused interactions - Being automatically selected based on task context Our system leverages these features by creating specialized agents for each development phase. ### 2. Workflow Phases #### Planning Phase 1. **spec-analyst**: Analyzes requirements and creates user stories 2. **spec-architect**: Designs system architecture 3. **spec-planner**: Breaks down work into tasks 4. **Quality Gate 1**: Validates planning completeness #### Development Phase 1. **spec-developer**: Implements code based on tasks 2. **spec-tester**: Writes comprehensive tests 3. **Quality Gate 2**: Validates code quality #### Validation Phase 1. **spec-reviewer**: Reviews code for best practices 2. **spec-validator**: Final production readiness check 3. **Quality Gate 3**: Ensures deployment readiness ### 3. Agent Communication Agents communicate through structured artifacts: - Each agent produces specific documents - Next agent uses previous outputs as input - Orchestrator manages the flow - Quality gates ensure consistency ## Agent Reference ### Workflow Agents | Agent | Purpose | Inputs | Outputs | |-------|---------|--------|---------| | spec-orchestrator | Workflow coordination | Project description | Status reports, routing | | spec-analyst | Requirements analysis | User description | requirements.md, user-stories.md | | spec-architect | System design | Requirements | architecture.md, api-spec.md | | spec-planner | Task planning | Architecture | tasks.md, test-plan.md | | spec-developer | Implementation | Tasks | Source code, unit tests | | spec-tester | Testing | Code | Test suites, coverage reports | | spec-reviewer | Code review | Code | Review report, improvements | | spec-validator | Final validation | All artifacts | Validation report, quality score | ### Specialist Agents | Agent | Domain | Integration Point | |-------|--------|-------------------| | ui-ux-master | UI/UX Design | Planning phase | | senior-backend-architect | Backend Systems | Architecture phase | | senior-frontend-architect | Frontend Systems | Development phase | | refactor-agent | Code Quality | Any phase | ## Usage Examples ### Example 1: Enterprise Applicationbash
### Example 2: Quick Prototypebash
### Example 3: Existing Requirementsbash
### Example 4: Specific Phase Onlybash
## Quality Gates ### Gate 1: Planning Quality (95% threshold) - Requirements completeness - Architecture feasibility - Task breakdown quality - User story clarity ### Gate 2: Development Quality (80% threshold) - Test coverage - Code quality metrics - Security scan results - Performance benchmarks ### Gate 3: Production Readiness (85% threshold) - Overall quality score - Documentation completeness - Deployment readiness - Operational requirements ## Best Practices ### 1. Project Preparation - Write clear project descriptions - Include constraints and requirements - Specify quality expectations - Provide existing documentation ### 2. Working with Agents - Let each agent complete their phase - Review artifacts between phases - Use feedback loops effectively - Trust the quality gates ### 3. Customization - Adjust quality thresholds based on needs - Skip agents for simpler projects - Add custom validation criteria - Integrate with existing workflows ### 4. Performance Optimization - Enable parallel execution for large projects - Cache results for iterative development - Use phase-specific execution - Monitor resource usage ## Advanced Usage ### Custom Workflowspython
### Integration with CI/CDyaml
### Extending the System 1. **Add New Agents** - Create agent with YAML frontmatter - Define clear responsibilities - Specify input/output formats - Update orchestrator routing 2. **Custom Quality Gates** - Define new criteria - Set appropriate thresholds - Implement validation logic - Add to workflow 3. **Domain-Specific Workflows** - Create specialized orchestrators - Define domain patterns - Customize quality criteria - Optimize for specific needs ## Troubleshooting ### Common Issues 1. **Agent Not Found** - Verify agents are in correct directory - Check YAML frontmatter format - Ensure proper file permissions 2. **Quality Gate Failures** - Review specific criteria that failed - Check artifact completeness - Allow agents to revise work - Consider adjusting thresholds 3. **Workflow Stuck** - Check orchestrator status - Review last agent output - Look for error messages - Restart from last checkpoint ### Debug Modebash
We welcome contributions! Please:
MIT License - see LICENSE file for details
For more information, see:
Getting started with and using leamas to install Claude agents and commands in your project or system wide.
Open your terminal and run this single command to install leamas on your system:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/leamas-ai/leamas.sh/main/install.sh)"
This downloads the leamas CLI script to $HOME/leamas/leamas
Add leamas to your system $PATH so you can run it from anywhere:
echo 'export PATH="$HOME:$PATH"' >> ~/.bashrc && source ~/.bashrc
For zsh users, replace ~/.bashrc with ~/.zshrc
Browse available kits above and install them with simple commands:
Install an agent kit locally (current project):
leamas agent@example-kit
Install globally (all projects):
leamas -g agent@example-kit
Install command kits:
leamas command@example-command
Once installed, Claude will automatically detect and use the agents and commands you've installed. They'll appear in Claude's interface and can be invoked based on context.
Check what's installed globally:
ls ~/.claude/agents/leamas/
ls ~/.claude/commands/leamas/
Or what's installed for your project:
ls .claude/agents/leamas/
ls .claude/commands/leamas/
~/.claude/agents/leamas/[kit-name] or .claude/agents/leamas/[kit-name] for local installations..claude/commands/leamas/[kit-name] directory.kits/agents/$AGENT_NAME directory and command md files in the kits/agents/$AGENT_NAME directory.
leamas is an open-source CLI tool that simplifies installing and managing* kits for Claude. It provides a simple command-line interface to download agents and commands that enhance Claude's capabilities.
This project is community-driven and all code is publicly available on GitHub. Have an agent or command to add? Open a pull request with your kit to have it added!
Once installed, leamas runs from your terminal anywhere on your system and will download kits from our curated repository.
* Managing kits coming soon...leamas is open source and welcomes contributions. Here's how you can help: