{"id":31581028,"url":"https://github.com/leonardmh/claude-code-agents","last_synced_at":"2025-10-05T21:52:19.469Z","repository":{"id":314855848,"uuid":"1057004556","full_name":"LeonardMH/claude-code-agents","owner":"LeonardMH","description":"User level agents for Claude Code","archived":false,"fork":false,"pushed_at":"2025-09-15T06:48:36.000Z","size":11,"stargazers_count":1,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2025-09-15T08:38:56.333Z","etag":null,"topics":["agentic-ai","claude-code"],"latest_commit_sha":null,"homepage":"","language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/LeonardMH.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-09-15T06:38:18.000Z","updated_at":"2025-09-15T06:51:08.000Z","dependencies_parsed_at":"2025-09-15T08:38:57.698Z","dependency_job_id":"e6838ffb-85aa-4003-a8b9-3cae33b303c0","html_url":"https://github.com/LeonardMH/claude-code-agents","commit_stats":null,"previous_names":["leonardmh/claude-code-agents"],"tags_count":5,"template":false,"template_full_name":null,"purl":"pkg:github/LeonardMH/claude-code-agents","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LeonardMH%2Fclaude-code-agents","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LeonardMH%2Fclaude-code-agents/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LeonardMH%2Fclaude-code-agents/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LeonardMH%2Fclaude-code-agents/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/LeonardMH","download_url":"https://codeload.github.com/LeonardMH/claude-code-agents/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LeonardMH%2Fclaude-code-agents/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":278526242,"owners_count":26001325,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-10-05T02:00:06.059Z","response_time":54,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["agentic-ai","claude-code"],"created_at":"2025-10-05T21:52:17.460Z","updated_at":"2025-10-05T21:52:19.456Z","avatar_url":"https://github.com/LeonardMH.png","language":null,"funding_links":[],"categories":[],"sub_categories":[],"readme":"# Claude Code Agents\n\nA specialized collection of focused agents for software development workflows.\nEach agent handles a specific aspect of development with clear boundaries and\ninter-agent communication capabilities.\n\n## Agent Architecture\n\nAgents are organized by color according to their role in the software development lifecycle and use different Claude models based on their complexity requirements:\n\n### Model Selection Rationale\n- **Opus**: Complex reasoning tasks requiring deep analysis and strategic thinking (planning, debugging, architectural decisions)\n- **Sonnet**: Balanced tasks requiring both capability and efficiency (building, reviewing, documentation, security analysis)\n- **Haiku**: Fast, focused tasks with clear objectives (searching, testing, exploring, analyzing)\n\n| Color | Role | Model |\n|-------|------|-------|\n| 🟣 Purple | Planning \u0026 Architecture | Opus |\n| 🟢 Green | Building \u0026 Implementation | Sonnet |\n| 🔵 Blue | Knowledge \u0026 Documentation | Sonnet, Haiku |\n| 🟡 Yellow | Quality Assurance | Sonnet, Haiku |\n| 🟠 Orange | Operations \u0026 Monitoring | Sonnet |\n| 🔴 Red | Incident Response | Haiku, Sonnet |\n\n## Available Agents\n\n### 🟣 Planning \u0026 Architecture\n\n#### **plan-requirements** (Opus)\n**When to use**: Transform vague user requests into comprehensive requirements and actionable development plans\n- Extracts true problems from requested solutions\n- Defines functional and non-functional requirements (performance, security, usability)\n- Identifies edge cases, dependencies, and constraints\n- Creates structured requirements documents with acceptance criteria\n- Establishes clear project scope and success criteria\n- **Creates**: `requirements.md` with problem statement, user flows, and assumptions\n- **Hands off to**: plan-api, build-code\n\n#### **plan-api** (Opus)\n**When to use**: Designs logical, consistent APIs and specifications that serve as contracts between system components\n- Creates comprehensive API specifications with method signatures, parameters, and return types\n- Ensures consistency across interface methods and data structures\n- Designs data models, validation schemas, and error handling patterns\n- Documents API usage patterns, examples, and evolution strategy\n- Validates API usability through common workflow analysis\n- **Flexible input**: Can work from requirements, existing codebase analysis, or standalone specifications\n- **Reads from**: plan-requirements (when designing from requirements)\n- **Hands off to**: build-code\n\n### 🟢 Building \u0026 Implementation\n\n#### **build-cli** (Sonnet)\n**When to use**: Design command-line interfaces with excellent user experience\n- Creates intuitive command structures and argument hierarchies\n- Designs configuration systems with clear precedence rules\n- Generates shell completions and help documentation\n- Ensures consistent error messaging and user guidance\n- Follows progressive disclosure principles for complex CLIs\n- **Reads from**: plan-requirements, plan-api\n- **Creates**: `.agent-handoffs/build-cli-\u003cuuid\u003e.md` with CLI specifications\n- **Hands off to**: build-code, write-docs\n\n#### **build-gui** (Sonnet)\n**When to use**: Design modern graphical user interfaces with cross-platform compatibility and accessibility\n- Designs component hierarchies and state management patterns\n- Selects appropriate frameworks and ensures cross-platform compatibility\n- Defines accessibility standards and responsive design strategies\n- Optimizes for performance and maintainability\n- Creates comprehensive UI specifications and design systems\n- **Reads from**: plan-requirements, plan-api\n- **Creates**: `.agent-handoffs/build-gui-\u003cuuid\u003e.md` with GUI specifications\n- **Hands off to**: build-code, check-tests, write-docs\n\n#### **build-code** (Sonnet)\n**When to use**: Transform requirements into clean, maintainable, production-ready code\n- Implements code following \"Make it work → Make it right → Make it fast\" principle\n- Follows existing codebase conventions and patterns\n- Implements proper error handling, validation, and resource management\n- Creates self-documenting code with clear naming and structure\n- Applies SOLID principles and avoids common anti-patterns\n- **Reads from**: plan-requirements, plan-api handoffs\n- **Hands off to**: check-quality, fix-build\n\n#### **build-hardware** (Sonnet)\n**When to use**: Design hardware interfaces and communication protocols for embedded systems and IoT devices\n- Designs hardware communication protocols and device drivers\n- Creates hardware abstraction layers for cross-platform compatibility\n- Interfaces with sensors, actuators, and embedded systems\n- Handles real-time data acquisition and control systems\n- Ensures reliable hardware-software integration patterns\n- **Reads from**: plan-requirements, plan-api handoffs\n- **Creates**: `.agent-handoffs/build-hardware-\u003cuuid\u003e.md` with hardware specifications\n- **Hands off to**: build-code, check-tests, write-docs\n\n#### **build-slides** (Sonnet)\n**When to use**: Design and create professional presentations with compelling visual storytelling and accessibility\n- Creates slide hierarchies and information architecture for presentations\n- Implements effective data visualizations and infographics\n- Designs presentation templates and visual design systems\n- Ensures accessibility compliance and cross-platform compatibility\n- Optimizes presentations for different delivery contexts (in-person, virtual, self-guided)\n- **Reads from**: plan-requirements, learn-slides handoffs\n- **Creates**: `.agent-handoffs/build-slides-\u003cuuid\u003e.md` with presentation specifications\n- **Hands off to**: build-code (for interactive elements), write-docs, check-ui\n\n#### **build-documents** (Sonnet)\n**When to use**: Create professional documents including Word (.docx), OpenDocument (.odt), and PDF files with sophisticated formatting\n- Designs document templates and style systems for consistent branding\n- Creates complex documents with advanced formatting, tables, and interactive features\n- Implements forms, automation pipelines, and document generation workflows\n- Builds template libraries and cross-format compatibility systems\n- Ensures accessibility compliance and professional quality output\n- **Reads from**: plan-requirements, learn-documents handoffs\n- **Creates**: `.agent-handoffs/build-documents-\u003cuuid\u003e.md` with document specifications\n- **Hands off to**: build-code (for automation), check-tests, write-docs\n\n#### **build-spreadsheet** (Sonnet)\n**When to use**: Create powerful, maintainable spreadsheets with robust formulas, data models, and automation\n- Designs logical spreadsheet structures and data models\n- Implements complex formulas, calculations, and data processing logic\n- Creates automated workflows with macros and scripting\n- Builds reusable templates and standardized formats\n- Ensures data integrity, validation, and error handling\n- **Reads from**: plan-requirements, learn-spreadsheet handoffs\n- **Creates**: `.agent-handoffs/build-spreadsheet-\u003cuuid\u003e.md` with spreadsheet specifications\n- **Hands off to**: build-code (for integrations), check-tests, write-docs\n\n### 🔵 Knowledge \u0026 Documentation\n\n#### **learn-codebase** (Haiku)\n**When to use**: Rapidly explore and map unfamiliar codebases to provide architectural understanding and structural overview\n- Maps project directory structure and organization patterns using fast tooling (fd, rg, tree)\n- Identifies key modules, packages, and their purposes with API surface discovery\n- Recognizes architectural patterns (MVC, microservices, layered architecture)\n- Maps dependencies, technology stack, and module relationships\n- Discovers entry points, configuration files, and build systems\n- **Exploration strategy**: Structure → Patterns → Dependencies → Entry Points → Technology Detection\n- **Output**: Project overview, module inventory, architecture patterns, technology stack summary\n- **Hands off to**: plan-requirements (system context), build-code (conventions), write-docs (architecture)\n\n#### **write-docs** (Sonnet)\n**When to use**: Creates comprehensive project documentation and user-facing guides that make code accessible\n- Generates user-facing documentation, README files, and setup guides\n- Creates API documentation from code specifications with practical examples\n- Writes inline code documentation, tutorials, and architectural documentation\n- Maintains consistency across all documentation using clear, simple language\n- **Writing principles**: Clarity, Completeness, Consistency, Currency, Examples\n- **Analysis process**: Assess → Understand → Plan → Write → Validate\n- **Reads from**: All agent handoffs for comprehensive project context\n- **Output**: Documentation summary, structure overview, key sections, maintenance notes\n- **Hands off to**: Final documentation deliverables and maintenance recommendations\n\n\n#### **learn-commits** (Haiku)\n**When to use**: Search git history for deleted, moved, or modified code artifacts\n- Efficiently searches for deleted or modified functions, variables, classes using `git log -S` and `-G`\n- Tracks code evolution and changes over time with historical context\n- Locates moved or renamed code artifacts using `git log --follow`\n- Provides complete code snippets with commit references and dates\n- **Search strategy**: Interprets intent, chooses appropriate git method, extracts results systematically\n- **Output**: Search summary, historical findings with evolution notes, and commit references\n- **Hands off to**: Any agent needing historical context or code recovery\n\n#### **learn-documents** (Haiku)\n**When to use**: Analyze, extract content from, or understand document files (.docx, .doc, .odt, .pdf)\n- Parses and analyzes documents using appropriate libraries (python-docx, odfpy, PyPDF2/pdfplumber)\n- Extracts text, images, tables, forms, and metadata from documents\n- Identifies document structure, formatting patterns, and organizational hierarchy\n- Processes interactive forms, fillable PDFs, and complex layouts with OCR support\n- Detects document quality issues, accessibility problems, and formatting inconsistencies\n- **Analysis methodology**: Assess → Structure → Content → Format → Report\n- **Output**: Document structure summary, content extraction, formatting patterns, accessibility assessment\n- **Hands off to**: plan-requirements (document context), build-documents (template creation), write-docs (content documentation)\n\n#### **learn-slides** (Haiku)\n**When to use**: Analyze, understand, or extract information from presentation files (.pptx, .odp, .key, .pdf presentations)\n- Parses and analyzes presentations using appropriate libraries (python-pptx, odfpy, PyPDF2)\n- Extracts content, images, charts, and multimedia from slides\n- Identifies design patterns, color schemes, branding elements, and template usage\n- Analyzes slide structure, hierarchies, and content organization\n- Categorizes slide types and assesses design consistency\n- **Analysis methodology**: Assess → Structure → Content → Design → Report\n- **Output**: Presentation structure summary, content extraction, design patterns identified\n- **Hands off to**: plan-requirements (presentation context), build-slides (template creation), write-docs (presentation documentation)\n\n#### **learn-spreadsheet** (Sonnet)\n**When to use**: Analyze, summarize, extract data from, or identify issues in spreadsheet files (.xlsx, .xlsm, .csv, .ods)\n- Parses and analyzes spreadsheet files using appropriate libraries (openpyxl, pandas, odfpy)\n- Extracts, transforms, and summarizes data from complex multi-sheet workbooks\n- Detects data quality issues: inconsistent types, formatting problems, formula errors, circular references\n- Creates reusable Python tools for common spreadsheet operations\n- Handles edge cases: corrupted files, massive datasets, encrypted content, non-standard formats\n- **Analysis methodology**: Assess → Structure → Quality → Report\n- **Output**: Data structure summary, quality issues found, extraction tools created\n- **Hands off to**: plan-requirements (data context), build-code (data integration), write-docs (data documentation)\n\n### 🟡 Quality Assurance\n\n#### **check-quality** (Sonnet)\n**When to use**: Review code for maintainability issues, anti-patterns, and quality concerns\n- Identifies code smells and anti-patterns (god objects, long methods, deep nesting, duplicated code)\n- Assesses maintainability, readability, and structural quality\n- Evaluates testability, error handling, and proper abstractions\n- Provides prioritized refactoring recommendations (critical, major, minor issues)\n- Focuses on genuine maintainability impact over stylistic preferences\n- **Reads from**: build-code handoffs\n- **Output**: Quality assessment with specific file:line references and actionable feedback\n- **Hands off to**: build-code (for improvements)\n\n#### **check-tests** (Haiku)\n**When to use**: Creates and executes comprehensive test suites for thorough code validation\n- Generates unit, integration, and end-to-end tests following Arrange-Act-Assert pattern\n- Supports multiple frameworks (Jest, Vitest, pytest, Go testing, Rust built-in)\n- Executes test suites and analyzes results with coverage reporting\n- Identifies failing tests, coverage gaps, and performance bottlenecks\n- Targets 80%+ line coverage with 100% coverage for critical business logic\n- **Testing methodology**: Analyze → Categorize → Design → Implement → Execute → Report\n- **Reads from**: build-code handoffs\n- **Output**: Test summary, failed test details, coverage gaps, and performance metrics\n- **Hands off to**: fix-runtime (for test failures)\n\n#### **check-ui** (Haiku)\n**When to use**: Automated GUI testing with visual regression, accessibility validation, and user experience testing\n- Executes visual regression testing and screenshot comparison\n- Validates accessibility compliance and keyboard navigation\n- Tests user interaction flows and UI responsiveness\n- Verifies cross-browser and cross-platform compatibility\n- Measures UI performance and animation smoothness\n- **Reads from**: build-gui, build-code handoffs\n- **Creates**: `.agent-handoffs/check-ui-\u003cuuid\u003e.md` with UI test results\n- **Hands off to**: build-code (for fixes), write-docs (for test documentation)\n\n### 🟠 Operations \u0026 Monitoring\n\n#### **profile-performance** (Sonnet)\n**When to use**: Identifies performance bottlenecks and optimization opportunities across applications and systems\n- Profiles CPU usage, memory consumption, I/O patterns, and concurrency issues\n- Analyzes runtime performance patterns, execution flows, and resource utilization\n- Identifies slow queries, operations, algorithmic inefficiencies, and memory leaks\n- Uses appropriate profiling tools (Chrome DevTools, py-spy, go tool pprof, perf, etc.)\n- **Analysis process**: Baseline → Profile → Analyze → Prioritize → Recommend\n- **Optimization categories**: Algorithmic, Database, Memory, I/O, Caching, Concurrency\n- **Metrics focus**: P50/P95/P99 latencies, throughput, resource usage, error rates\n- **Output**: Performance summary, critical bottlenecks, optimization opportunities, implementation priorities\n- **Hands off to**: build-code (for optimizations)\n\n### 🔴 Incident Response\n\n#### **fix-runtime** (Sonnet)\n**When to use**: Investigate runtime bugs, crashes, and production issues with systematic analysis\n- Analyzes runtime exceptions, stack traces, and crash dumps\n- Investigates performance issues, memory leaks, and resource problems\n- Debugs race conditions, timing bugs, and concurrency issues\n- Traces user-reported behavioral issues through code execution paths\n- **NOT for**: Build/compilation errors (use fix-build)\n- **Output**: Clear problem statement, root cause analysis, and specific fix recommendations\n- **Hands off to**: build-code (for fixes)\n\n#### **fix-build** (Haiku)\n**When to use**: Build projects and analyze compilation/build errors with automatic system detection\n- Detects build systems automatically (npm/yarn, Maven, Gradle, Make, Cargo, CMake)\n- Executes appropriate build commands and captures output\n- Classifies errors by category (syntax, type, reference, dependency, configuration, linking)\n- Provides specific, actionable fix recommendations for each error\n- **NOT for**: Runtime issues (use fix-runtime)\n- **Output**: Build status, critical errors, error classification, and fix recommendations\n- **Hands off to**: build-code (for fixes)\n\n#### **fix-security** (Sonnet)\n**When to use**: Scans for security vulnerabilities and compliance issues with defensive security focus\n- Identifies OWASP Top 10 and common security vulnerabilities across web apps, APIs, and databases\n- Reviews authentication, authorization, session management, and access control mechanisms\n- Detects exposed secrets, credentials, and sensitive data using static analysis tools\n- Validates input sanitization, output encoding, and injection prevention measures\n- Assesses cryptographic implementations, SSL/TLS configurations, and secure communication\n- **Assessment areas**: Authentication/Authorization, Data Protection, Infrastructure Security, Code Security\n- **Priority levels**: Critical → High → Medium → Low with specific remediation guidance\n- **Reads from**: build-code handoffs\n- **Output**: Executive summary, critical vulnerabilities, detailed findings, and compliance status\n- **Hands off to**: build-code (for security fixes)\n\n## Agent Communication\n\nAll agents communicate through the `.agent-handoffs/` shared workspace using structured markdown files with the naming convention `\u003cagent-role-name\u003e-\u003cshort-uuid\u003e.md`. This system enables:\n\n- **Context preservation**: Each agent documents findings, decisions, and recommendations\n- **Coordinated workflows**: Agents read relevant handoffs before starting work\n- **Knowledge sharing**: Historical analysis and implementation context passed between agents\n- **Quality tracking**: Implementation details and testing needs communicated across the pipeline\n\n### Handoff File Structure\nEach handoff file contains:\n- **Summary**: Brief overview of work completed\n- **Key Findings**: Important discoveries or results\n- **Context for Next Agent**: What the next agent needs to know\n- **Recommendations**: Specific actions or considerations\n- **Files/Components Affected**: Relevant code locations with line numbers\n\nSee `handoff-system.md` for complete documentation and agent-specific handoff patterns.\n\n## Installation\n\n### Method 1: Git Clone with Symlinks\nClone this repository and create symlinks to your agents directory for easy updates:\n\n```bash\n# Clone the repository\ngit clone https://github.com/LeonardMH/claude-code-agents.git ~/claude-code-agents\n\n# Create symlinks to agents directory\nmkdir -p ~/.claude/agents \u0026\u0026 ln -sf ~/claude-code-agents/*.md ~/.claude/agents/\n```\n\nTo update agents: `cd ~/claude-code-agents \u0026\u0026 git pull`\n\n### Method 2: Manual Download\nDownload individual agent `.md` files from this repository and place them in your Claude Code agents directory (`~/.claude/agents/`). They'll be available for use the next time you start `claude`.\n\n### Directory Structure\nAfter installation, your `~/.claude/agents/` directory will contain all agent `.md` files and supporting documentation.\n\n## Workflow Examples\n\n### New Feature Development\n1. **plan-requirements** → Transform vague request into clear requirements with acceptance criteria\n2. **plan-api** → Design consistent interfaces and data models (if needed)\n3. **build-code** → Build clean, maintainable implementation following best practices\n4. **fix-build** → Ensure code compiles and builds successfully\n5. **check-tests** → Create comprehensive test suite with good coverage\n6. **check-quality** → Quality assessment and refactoring recommendations\n7. **fix-security** → Security vulnerability assessment (for security-sensitive features)\n8. **write-docs** → Create user-facing documentation and API docs\n\n### CLI Tool Development\n1. **plan-requirements** → Define CLI tool requirements and user workflows\n2. **build-cli** → Design command structure, arguments, and user interaction patterns\n3. **build-code** → Build the CLI application following design specifications\n4. **check-tests** → Create CLI integration and command tests\n5. **write-docs** → Generate user guides and man pages\n\n### GUI Application Development\n1. **plan-requirements** → Define UI requirements and user stories\n2. **build-gui** → Design component architecture, state management, and accessibility patterns\n3. **build-code** → Build UI components and application logic\n4. **check-ui** → Execute visual regression testing and accessibility validation\n5. **check-tests** → Create comprehensive test coverage for functionality\n6. **write-docs** → Create user guides and component documentation\n\n### Hardware Integration Development\n1. **plan-requirements** → Define hardware interface requirements and constraints\n2. **build-hardware** → Design communication protocols and hardware abstraction layers\n3. **build-code** → Implement device drivers and hardware interfaces\n4. **check-tests** → Create hardware simulation tests and integration validation\n5. **write-docs** → Document hardware setup and troubleshooting procedures\n\n### Bug Investigation \u0026 Fix\n1. **fix-runtime** → Systematic analysis of runtime issue with root cause identification\n2. **learn-commits** → Find historical context or previous implementations (if needed)\n3. **build-code** → Implement targeted fix based on root cause analysis\n4. **check-tests** → Add regression tests to prevent future occurrences\n5. **check-quality** → Review fix for quality and unintended side effects\n\n### Performance Optimization\n1. **profile-performance** → Identify bottlenecks using appropriate profiling tools\n2. **build-code** → Implement optimizations based on profiling results\n3. **check-tests** → Validate performance improvements and ensure functionality\n4. **check-quality** → Review optimized code for maintainability\n\n### Legacy Code Analysis\n1. **learn-codebase** → Map current codebase structure and identify key architectural patterns\n2. **learn-commits** → Search for historical implementations and evolution patterns\n3. **check-quality** → Assess current code quality and identify improvement opportunities\n4. **fix-security** → Check for security vulnerabilities in legacy code\n5. **write-docs** → Document findings and create improvement roadmap\n\n### Unfamiliar Codebase Integration\n1. **learn-codebase** → Rapidly map project structure, modules, and architectural patterns\n2. **plan-requirements** → Analyze how new requirements fit within existing architecture\n3. **plan-api** → Design interfaces that align with existing patterns (if needed)\n4. **build-code** → Implement following discovered conventions and patterns\n5. **check-tests** → Create tests using existing testing frameworks and patterns\n\n### Data Analysis \u0026 Integration\n1. **learn-spreadsheet** → Analyze data structure, quality issues, and extract insights from spreadsheet files\n2. **plan-requirements** → Transform data insights into feature requirements\n3. **plan-api** → Design data models and interfaces for spreadsheet integration\n4. **build-code** → Build data processing and integration features\n5. **check-tests** → Validate data processing accuracy and edge cases\n\n### Presentation Creation \u0026 Automation\n1. **plan-requirements** → Define presentation objectives, audience, and content requirements\n2. **learn-slides** → Analyze existing templates, brand guidelines, or reference presentations\n3. **build-slides** → Design presentation structure, templates, and visual hierarchy\n4. **build-code** → Generate dynamic content, data visualizations, or interactive elements\n5. **check-ui** → Validate accessibility and cross-platform compatibility\n6. **write-docs** → Document presentation templates and usage guidelines\n\n### Spreadsheet Development \u0026 Automation\n1. **plan-requirements** → Define data processing needs, calculations, and business rules\n2. **learn-spreadsheet** → Analyze existing data sources and current spreadsheet processes\n3. **build-spreadsheet** → Create robust spreadsheet models with formulas and validation\n4. **build-code** → Implement automation scripts, macros, or external integrations\n5. **check-tests** → Validate calculations, edge cases, and data integrity\n6. **write-docs** → Create user guides and maintenance documentation\n\n### Business Reporting \u0026 Analytics Workflow\n1. **learn-spreadsheet** → Analyze current data sources and reporting requirements\n2. **plan-requirements** → Define comprehensive reporting and analytics requirements\n3. **build-spreadsheet** → Create data processing and calculation engines\n4. **build-slides** → Design executive dashboards and presentation templates\n5. **build-code** → Implement automated data pipelines and report generation\n6. **check-tests** → Validate data accuracy and report consistency\n7. **write-docs** → Document reporting processes and maintenance procedures\n\n### Document Processing \u0026 Automation\n1. **learn-documents** → Analyze existing forms, contracts, or document templates\n2. **plan-requirements** → Define document automation and generation requirements\n3. **build-documents** → Create document templates, forms, and generation systems\n4. **build-code** → Implement document automation pipelines and data integration\n5. **check-tests** → Validate document generation, forms, and data processing\n6. **write-docs** → Document template usage and maintenance procedures\n\n### Complete Office Suite Integration\n1. **learn-documents** → Extract data and requirements from existing Word/PDF documents\n2. **learn-spreadsheet** → Analyze data processing needs from extracted information\n3. **plan-requirements** → Define comprehensive office automation workflow\n4. **build-spreadsheet** → Create data processing and calculation models\n5. **build-documents** → Generate professional reports and documentation\n6. **build-slides** → Create presentation templates from document content\n7. **build-code** → Implement end-to-end office automation system\n8. **check-tests** → Validate entire workflow from data input to document output\n9. **write-docs** → Document complete office automation system\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fleonardmh%2Fclaude-code-agents","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fleonardmh%2Fclaude-code-agents","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fleonardmh%2Fclaude-code-agents/lists"}