Claude Code Automation Framework

A systematic development framework that guides Claude through building production-ready applications across multiple domains using template-driven development, quality gates, and structured workflows.

What This Skill Does

This skill enables Claude to work with the Claude Code Automation Framework - a comprehensive system that provides:

Supported Application Types

Instructions

Phase 1: Project Initialization

1. **Start with the Project Wizard**:

```bash

python framework/tools/project_wizard.py

```

- Select application type from available templates

- Choose appropriate tech stack profile

- Wizard generates directory structure and instantiates PRD template

2. **Verify Directory Structure**:

```

{project_name}/

├── deliverables/

│ ├── PRD.md

│ ├── src/

│ ├── test/

│ ├── docs/

│ └── requirements.txt

```

Phase 2: Requirements Definition

3. **Generate Comprehensive PRD**:

- Use domain-specific template from `templates/application_types/`

- Fill in all placeholder variables with project-specific details

- Include user stories, functional requirements, and non-goals

- Ensure all sections are complete before proceeding

4. **Review Quality Gates**:

- PRD addresses all template requirements

- Non-goals section prevents scope creep

- Success metrics are measurable

Phase 3: Development Planning

5. **Create TodoWrite Task List**:

- Break PRD requirements into specific, actionable tasks

- Use clear task descriptions with both imperative and active forms

- Example tasks:

- content: "Set up project structure and dependencies"

- activeForm: "Setting up project structure and dependencies"

- Organize tasks by feature or component

6. **Set Up Development Environment**:

- Follow tech stack profile instructions from `tech_stacks/`

- Install dependencies per `requirements.txt` or `package.json`

- Configure testing frameworks and tools

Phase 4: Implementation

7. **Follow Architecture Patterns**:

- Use template-driven development approach

- Implement domain-specific guidance from tech stack profile

- Apply built-in standards for error handling and validation

8. **Maintain TodoWrite Progress**:

- Mark ONE task as `in_progress` at a time

- Complete current task before starting next one

- Update task status in real-time as you work

9. **User Interaction Protocol**:

- Ring bell (`echo -e "\a"`) when requesting user input

- Use triple bell warning (`echo -e "\a\a\a"`) for data fallbacks

- Display clear notifications: "⚠️ REAL DATA NOT AVAILABLE"

- Always provide option to stop execution vs. using fallback

Phase 5: Testing

10. **Run Comprehensive Test Suite**:

```bash

python test/run_tests.py

```

- Generates timestamped reports: `test/reports/test_results_YYYY-MM-DD-HH:MM.txt`

- Achieves >80% test coverage (quality gate requirement)

11. **Multi-Level Testing Strategy** (varies by application type):

- **CLI Tools**: pytest + click.testing.CliRunner + pytest-cov

- **Web Apps**: Jest (frontend) + pytest (backend)

- **APIs**: pytest + httpx/supertest for endpoint testing

- **ML Systems**: pytest + model validation + performance metrics

- **Desktop Apps**: pytest + GUI testing frameworks

12. **Timestamp Standards**:

- Format: `YYYY-MM-DD-HH:mm` for all files and logs

- Code: `datetime.now().strftime('%Y-%m-%d-%H:%M')`

- Examples: `training_results_2025-06-27-12:30.csv`, `model_plot_2025-06-27-12:30.png`

Phase 6: Documentation

13. **Generate User Documentation**:

- Installation instructions

- Usage examples with screenshots/code samples

- Configuration options

- Troubleshooting guide

14. **Generate Developer Documentation**:

- Architecture overview

- API reference

- Testing instructions

- Contribution guidelines

15. **Visualization Standards** (for ML/data projects):

- Include model name in plot titles: `fig.suptitle(f'{model_name} Training Progress')`

- Auto-save all plots with timestamps

- Use non-blocking display: `plt.show(block=False)`

- File naming: `{model_name}_{plot_type}_{timestamp}.png`

Quality Gates Checklist

Before considering a project complete, verify:

Tech Stack Quick Reference

| Stack | Use Case | Key Files |

|-------|----------|-----------|

| `python_cli_tool.yaml` | CLI Tools | Click + rich + pytest |

| `fastapi_microservice.yaml` | REST APIs | FastAPI + SQLAlchemy + Redis |

| `web_fullstack_react_python.yaml` | Web Apps | React + TypeScript + FastAPI/Django |

Example Project

Reference the **calculator example** (`examples/calculator/`) for a complete implementation demonstrating:

Key Principles

1. **Always follow the 6-phase workflow** - don't skip phases

2. **Use templates** - don't create requirements from scratch

3. **Leverage tech stack profiles** - they contain proven configurations

4. **Maintain timestamped test reports** - use provided test runners

5. **Focus on quality gates** - each phase has specific deliverables

6. **Systematic over ad-hoc** - framework eliminates decision paralysis

Benefits

Important Notes