Skip to main content

CODITECT Cookbook

Version: 2.0.0 Last Updated: December 22, 2025 Audience: All CODITECT users

Prerequisites​

Before using these recipes, ensure you have:

  • CODITECT environment set up - Completed Welcome Aboard guide
  • Virtual environment active - source .venv/bin/activate
  • Basic Task Tool Pattern knowledge - Understanding of Task(subagent_type="...", prompt="...")
  • Claude Code CLI installed - For slash command execution

Quick verification:

source .venv/bin/activate
python3 --version  # 3.10+
claude --version   # Claude Code installed

Quick Start​

Use your first recipe in 3 steps:

Step 1: Choose Your Recipe​

Browse the Quick Recipe Reference table below to find a recipe matching your need.

Step 2: Copy and Customize​

Copy the recipe command, replacing [placeholders] with your specific values:

Task(
  subagent_type="orchestrator",
  prompt="create a new project for [your description here]"
)

Step 3: Execute and Iterate​

Run the command and review the output. Add more context to the prompt for better results.

What is This?​

The comprehensive CODITECT cookbook covering:

  • 30 Ready-to-Use Recipes - Copy, customize, execute (17 software + 13 business/research)
  • Agent Selection Guide - Which agent for which task
  • Orchestration Patterns - Multi-agent coordination
  • MoE Strategies - Mixture of Experts with analysts and judges
  • Complete Component Reference - 130+ agents, 141 commands, 186 skills, 233 scripts

How to use:

  1. Find the recipe matching what you want to do
  2. Copy the commands/invocations
  3. Customize the placeholders [like this]
  4. Execute!

Table of Contents​

  1. Quick Recipe Reference
  2. Agent Selection Guide
  3. Orchestration Patterns
  4. MoE Strategies
  5. Recipes 1-17
  6. Component Reference

Quick Recipe Reference​

I want to...Recipe
Start a new projectRecipe 1
Design a databaseRecipe 2
Create an API endpointRecipe 3
Add authenticationRecipe 4
Write testsRecipe 5
Debug an errorRecipe 6
Review my codeRecipe 7
Improve performanceRecipe 8
Add a frontend componentRecipe 9
Deploy my projectRecipe 10
Document my codeRecipe 11
Refactor existing codeRecipe 12
Research a technologyRecipe 13
Plan a featureRecipe 14
Fix a security issueRecipe 15
Sync git changesRecipe 16
Execute workflowRecipe 17
Business & Research
Create market analysisRecipe 18
Analyze competitorsRecipe 19
Write business planRecipe 20
Assess investment readinessRecipe 21
Design curriculumRecipe 22
Create assessmentsRecipe 23
Plan content marketingRecipe 24
Research a topicRecipe 25
Profile person/companyRecipe 26
Design hiring processRecipe 27
Create financial modelRecipe 28
Compliance checklistRecipe 29
Write project proposalRecipe 30

Agent Selection Guide​

How to Choose the Right Agent​

CODITECT has 130+ specialized agents. Here's how to select the right one:

Decision Tree​

What do you need?
│
├─ PLANNING & COORDINATION
│   ├─ Multi-step complex task → orchestrator
│   ├─ Feature planning → project-discovery-specialist
│   └─ Architecture decisions → senior-architect
│
├─ CODE DEVELOPMENT
│   ├─ Backend/API → backend-architect, actix-web-specialist
│   ├─ Frontend → frontend-react-typescript-expert, vue-specialist
│   ├─ Database → database-architect, foundationdb-expert
│   └─ Mobile → flutter-developer, react-native-developer
│
├─ CODE QUALITY
│   ├─ Review code → code-reviewer, comprehensive-review
│   ├─ Debug issues → debugger, error-debugging
│   ├─ Refactor → senior-architect
│   └─ Performance → application-performance, performance-profiler
│
├─ TESTING
│   ├─ Unit tests → testing-specialist, unit-testing
│   ├─ TDD workflow → tdd-workflows
│   └─ QA review → codi-qa-specialist, rust-qa-specialist
│
├─ SECURITY
│   ├─ Security audit → security-specialist, security-auditor
│   ├─ Penetration testing → penetration-testing-agent
│   └─ API security → backend-api-security
│
├─ DEVOPS & DEPLOYMENT
│   ├─ CI/CD → devops-engineer, cicd-automation
│   ├─ Cloud infrastructure → cloud-architect
│   ├─ Kubernetes → k8s-statefulset-specialist
│   └─ Monitoring → monitoring-specialist
│
├─ DOCUMENTATION
│   ├─ Technical docs → codi-documentation-writer
│   ├─ API docs → documentation-generation
│   └─ Doc organization → documentation-librarian
│
├─ RESEARCH & ANALYSIS
│   ├─ Market research → competitive-market-analyst
│   ├─ Business analysis → business-intelligence-analyst
│   ├─ Web research → web-search-researcher
│   └─ Codebase exploration → Explore, codebase-analyzer
│
└─ SPECIALIZED
    ├─ AI/ML → ai-specialist, mlops-specialist
    ├─ Blockchain → blockchain-developer
    └─ WebSocket/Real-time → websocket-protocol-designer

Top 20 Most-Used Agents​

AgentUse CaseExample Prompt
orchestratorMulti-agent coordination"Coordinate full feature development"
ExploreCodebase exploration"Find all API endpoints"
debuggerBug investigation"Analyze this error and find root cause"
code-reviewerCode quality"Review this PR for issues"
senior-architectArchitecture decisions"Design microservices structure"
database-architectDatabase design"Create schema for user management"
backend-architectAPI design"Create CRUD endpoints"
security-specialistSecurity audit"Audit authentication flow"
devops-engineerCI/CD setup"Create GitHub Actions pipeline"
testing-specialistTest creation"Write integration tests"
frontend-react-typescript-expertReact development"Create data table component"
codi-documentation-writerDocumentation"Generate API documentation"
cloud-architectCloud infrastructure"Design GCP deployment"
business-intelligence-analystBusiness analysis"Create market analysis"
research-agentTechnology research"Compare Redis vs Memcached"
competitive-market-analystCompetitive analysis"Analyze competitor pricing"
performance-profilerPerformance optimization"Profile slow API endpoint"
council-orchestratorMulti-agent reviews"Coordinate code review council"
workflow-orchestratorWorkflow execution"Execute deployment workflow"
project-organizerProject structure"Organize project directories"

Orchestration Patterns​

Pattern 1: Sequential Pipeline​

Run agents in sequence, passing output to the next:

# Phase 1: Architecture
Task(
    subagent_type="senior-architect",
    prompt="Design system architecture for [feature]. Output: architecture.md"
)

# Phase 2: Database (uses architecture output)
Task(
    subagent_type="database-architect",
    prompt="Based on architecture.md, design the database schema. Output: schema.sql"
)

# Phase 3: Implementation (uses both outputs)
Task(
    subagent_type="backend-architect",
    prompt="Implement API endpoints per architecture.md and schema.sql"
)

Pattern 2: Parallel Analysis​

Run multiple agents simultaneously for different perspectives:

# Launch in parallel
Task(
    subagent_type="code-reviewer",
    prompt="Review src/ for code quality issues"
)

Task(
    subagent_type="security-specialist",
    prompt="Audit src/ for security vulnerabilities"
)

Task(
    subagent_type="performance-profiler",
    prompt="Analyze src/ for performance bottlenecks"
)

# Synthesize results
Task(
    subagent_type="orchestrator",
    prompt="Synthesize findings from code review, security audit, and performance analysis into actionable recommendations"
)

Pattern 3: Orchestrator Delegation​

Let the orchestrator manage the workflow:

Task(
    subagent_type="orchestrator",
    prompt="""Implement [feature] end-to-end:

    1. Design architecture (senior-architect)
    2. Design database (database-architect)
    3. Implement backend (backend-architect)
    4. Write tests (testing-specialist)
    5. Review code (code-reviewer)
    6. Document (codi-documentation-writer)

    Coordinate all phases and produce final summary."""
)

Pattern 4: Council Review​

Multiple reviewers with synthesis:

Task(
    subagent_type="council-orchestrator",
    prompt="""Conduct code review council for [PR/feature]:

    Reviewers:
    - code-reviewer: Quality and best practices
    - security-specialist: Security vulnerabilities
    - cloud-architect: Cloud-native patterns
    - testing-specialist: Test coverage

    Output: Unified verdict with go/no-go recommendation"""
)

MoE Strategies (Mixture of Experts)​

What is MoE?​

Mixture of Experts (MoE) uses multiple specialized agents to provide comprehensive analysis. CODITECT supports two MoE patterns:

MoE with Analysts​

Multiple analysts examine different aspects, then results are synthesized:

# Strategy Brief Generation (5 analysts)
Task(
    subagent_type="strategy-brief-generator",
    prompt="""Generate executive strategy brief for [product]:

    Analysts:
    1. market-researcher: TAM/SAM/SOM, market dynamics
    2. competitive-analyst: Competitor landscape, positioning
    3. trend-analyst: Technology trends, disruption analysis
    4. framework-specialist: SWOT, Porter's Five Forces
    5. synthesis-writer: Final executive summary

    Output: McKinsey-quality strategy brief"""
)

Individual Analyst Invocation:

# Market Research Analyst
Task(
    subagent_type="market-researcher",
    prompt="Calculate TAM/SAM/SOM for [market]. Include growth rates and geographic segmentation."
)

# Competitive Analyst
Task(
    subagent_type="competitive-analyst",
    prompt="Profile top 5 competitors: pricing, features, target market, strengths/weaknesses."
)

# Trend Analyst
Task(
    subagent_type="trend-analyst",
    prompt="Identify technology trends affecting [industry]. Include adoption curves and disruption potential."
)

MoE with Judges​

Multiple judges evaluate from different criteria, then a chairman synthesizes:

# Code Review Council (3 judges + chairman)
Task(
    subagent_type="council-orchestrator",
    prompt="""Review [feature/PR] with judge panel:

    Judges:
    1. code-reviewer: Code quality (maintainability, readability)
    2. security-specialist: Security vulnerabilities (OWASP Top 10)
    3. cloud-architect: Cloud patterns (scalability, deployment)

    Chairman: council-chairman synthesizes verdicts

    Scoring: 0-10 per criteria
    Threshold: Average >= 7 for approval

    Output: APPROVE/REJECT with detailed findings"""
)

Detailed Judge Commands:

# MoE Analysis Command
/moe-analyze --topic "API authentication design" --analysts 3

# MoE Judge Command
/moe-judge --artifact "src/auth/" --judges security,quality,performance

Uncertainty-Aware MoE​

For high-stakes decisions with confidence scoring:

Task(
    subagent_type="uncertainty-orchestrator",
    prompt="""Evaluate [decision] with uncertainty quantification:

    Analysts provide:
    - Assessment (0-10)
    - Confidence level (0-1)
    - Evidence strength (strong/moderate/weak)

    Aggregate using weighted confidence.

    Output: Final recommendation with uncertainty bounds."""
)

When to Use MoE​

ScenarioPatternWhy
Strategy/planningAnalystsMultiple perspectives needed
Code reviewJudgesQuality gate with scoring
High-stakes decisionsUncertainty MoENeed confidence bounds
Complex researchAnalystsDomain expertise required
Compliance checksJudgesPass/fail criteria

Recipe 1: Start a New Project​

Goal: Create a new project with proper structure and planning.

Quick Version​

/new-project "Build [your project description]"
/new-project --guided "Build [your project description]"

With Specific Stack​

Task(
  subagent_type="orchestrator",
  prompt="create a new project for [description].
  Tech stack: [Python/FastAPI | Node/Express | React | etc.]
  Include: PROJECT-PLAN.md, TASKLIST.md, and starter code templates."
)

Output​

  • [project-name]/ directory with full structure
  • docs/project-management/PROJECT-PLAN.md
  • docs/project-management/TASKLIST.md
  • Starter code templates

Recipe 2: Design a Database​

Goal: Create a database schema for your project.

Quick Version​

Task(
  subagent_type="database-architect",
  prompt="design a database schema for
  [describe your data needs]. Include tables, relationships, and indexes."
)

Detailed Version​

Task(
  subagent_type="database-architect",
  prompt="design a complete database schema.

  Application: [your app description]
  Database type: [PostgreSQL | MySQL | SQLite | MongoDB]

  Required entities:
  - [Entity 1]: [fields]
  - [Entity 2]: [fields]
  - [Entity 3]: [fields]

  Relationships:
  - [Entity 1] has many [Entity 2]
  - [Entity 2] belongs to [Entity 3]

  Please provide:
  1. Complete schema with CREATE TABLE statements
  2. Index recommendations
  3. Migration file
  4. Sample seed data"
)

Output​

  • SQL schema file
  • Migration script
  • ERD diagram (if requested)
  • Seed data

Recipe 3: Create an API Endpoint​

Goal: Add a new REST API endpoint.

Quick Version​

Task(
  subagent_type="backend-architect",
  prompt="create a [GET|POST|PUT|DELETE]
  endpoint at /api/[resource] that [describes what it does]."
)

Full CRUD​

Task(
  subagent_type="backend-architect",
  prompt="create complete CRUD endpoints
  for [resource name].

  Framework: [Express | FastAPI | Actix | etc.]

  Endpoints needed:
  - GET /api/[resources] - List all
  - GET /api/[resources]/:id - Get one
  - POST /api/[resources] - Create
  - PUT /api/[resources]/:id - Update
  - DELETE /api/[resources]/:id - Delete

  Include:
  - Request/response schemas
  - Input validation
  - Error handling
  - Example curl commands"
)

Output​

  • Route handler code
  • Request/response types
  • Validation logic
  • Test examples

Recipe 4: Add Authentication​

Goal: Implement user authentication.

JWT Authentication​

Task(
  subagent_type="security-specialist",
  prompt="implement JWT authentication.

  Framework: [your framework]

  Requirements:
  - User registration endpoint
  - Login endpoint (returns JWT)
  - Password hashing (bcrypt)
  - Protected route middleware
  - Token refresh mechanism

  Include security best practices for:
  - Token expiration
  - Secure password storage
  - CORS configuration"
)

OAuth/Social Login​

Task(
  subagent_type="security-specialist",
  prompt="implement OAuth authentication
  with [Google | GitHub | etc.].

  Framework: [your framework]

  Flow:
  1. Redirect to provider
  2. Handle callback
  3. Create/update user in database
  4. Issue session or JWT

  Include environment variable configuration."
)

Output​

  • Auth middleware
  • Login/register routes
  • User model updates
  • Environment config

Recipe 5: Write Tests​

Goal: Add tests for your code.

Unit Tests​

Task(
  subagent_type="testing-specialist",
  prompt="write unit tests for [file/function].

  Test framework: [Jest | pytest | etc.]

  Cover:
  - Happy path
  - Edge cases
  - Error conditions

  Use mocks for: [external dependencies]"
)

Integration Tests​

Task(
  subagent_type="testing-specialist",
  prompt="write integration tests for
  the [feature/API endpoint].

  Test framework: [your framework]

  Include:
  - Database setup/teardown
  - API request tests
  - Response validation
  - Error scenario tests"
)

Test Coverage Report​

Task(
  subagent_type="testing-specialist",
  prompt="analyze test coverage for
  this project and recommend additional tests to reach 80% coverage."
)

Output​

  • Test files
  • Mock configurations
  • Coverage report

Recipe 6: Debug an Error​

Goal: Find and fix a bug.

Error Analysis​

Task(
  subagent_type="debugger",
  prompt="analyze this error and find the root cause:

  Error message:
  [paste error message]

  Context:
  - File: [filename]
  - What I was trying to do: [action]
  - What happened instead: [behavior]

  Please provide:
  1. Root cause analysis
  2. Step-by-step fix
  3. How to prevent this in the future"
)

Performance Issue​

Task(
  subagent_type="debugger",
  prompt="diagnose a performance issue:

  Symptom: [slow response, high memory, etc.]
  Where: [specific area]
  When: [conditions when it happens]

  Please analyze and suggest optimizations."
)

Output​

  • Root cause explanation
  • Fix implementation
  • Prevention recommendations

Recipe 7: Review My Code​

Goal: Get feedback on code quality.

General Review​

Task(
  subagent_type="code-reviewer",
  prompt="review [file or feature].

  Review for:
  - Code quality and readability
  - Potential bugs
  - Performance issues
  - Security vulnerabilities
  - Best practices

  Provide specific, actionable feedback."
)

Pre-Commit Review​

Task(
  subagent_type="code-reviewer",
  prompt="review my changes before commit.

  Changed files: [list or 'git diff']

  Check for:
  - Breaking changes
  - Missing tests
  - Documentation updates needed
  - Coding standards compliance"
)

Output​

  • Issue list with severity
  • Specific suggestions
  • Example improvements

Recipe 8: Improve Performance​

Goal: Optimize slow code.

Performance Audit​

Task(
  subagent_type="application-performance",
  prompt="audit performance of [area].

  Current metrics:
  - Response time: [current]
  - Memory usage: [current]

  Target:
  - Response time: [target]
  - Memory usage: [target]

  Analyze and recommend optimizations."
)

Database Query Optimization​

Task(
  subagent_type="database-architect",
  prompt="optimize this query:

  [paste slow query]

  Current execution time: [time]
  Table sizes: [approximate rows]

  Please provide:
  1. Query analysis
  2. Index recommendations
  3. Optimized query version"
)

Output​

  • Performance analysis
  • Optimization recommendations
  • Implementation code

Recipe 9: Add a Frontend Component​

Goal: Create a new UI component.

React Component​

Task(
  subagent_type="frontend-react-typescript-expert",
  prompt="create a
  [component name] component.

  Requirements:
  - [list what it should do]

  Props:
  - [prop1]: [type] - [description]
  - [prop2]: [type] - [description]

  Include:
  - TypeScript types
  - CSS/styling (Tailwind preferred)
  - Unit tests
  - Storybook story (if applicable)"
)

Form Component​

Task(
  subagent_type="frontend-react-typescript-expert",
  prompt="create a form for
  [purpose].

  Fields:
  - [field1]: [type] - [validation]
  - [field2]: [type] - [validation]

  Include:
  - Form validation
  - Error display
  - Loading state
  - Submit handler
  - Accessibility (a11y)"
)

Output​

  • Component code
  • Types/interfaces
  • Styles
  • Tests

Recipe 10: Deploy My Project​

Goal: Deploy to production.

Docker Deployment​

Task(
  subagent_type="devops-engineer",
  prompt="create Docker deployment configuration.

  Application: [type - Node, Python, etc.]
  Database: [if any]
  Environment: [production requirements]

  Create:
  - Dockerfile (multi-stage, optimized)
  - docker-compose.yml
  - .dockerignore
  - Environment variable handling"
)

CI/CD Pipeline​

Task(
  subagent_type="devops-engineer",
  prompt="create a CI/CD pipeline.

  Platform: [GitHub Actions | GitLab CI | etc.]
  Deployment target: [AWS | GCP | Vercel | etc.]

  Pipeline stages:
  1. Test
  2. Build
  3. Deploy to staging
  4. Deploy to production (manual approval)

  Include:
  - Environment secrets handling
  - Rollback strategy
  - Notification on failure"
)

Output​

  • Dockerfile
  • CI/CD configuration
  • Deployment scripts
  • Documentation

Recipe 11: Document My Code​

Goal: Create or improve documentation.

API Documentation​

Task(
  subagent_type="codi-documentation-writer",
  prompt="create API documentation.

  Include:
  - OpenAPI/Swagger spec
  - Endpoint descriptions
  - Request/response examples
  - Authentication instructions
  - Error codes reference"
)

README Generation​

Task(
  subagent_type="codi-documentation-writer",
  prompt="create a comprehensive
  README.md for this project.

  Include:
  - Project description
  - Features list
  - Installation instructions
  - Usage examples
  - Configuration options
  - Contributing guidelines
  - License"
)

Code Comments​

Task(
  subagent_type="codi-documentation-writer",
  prompt="add documentation to
  [file or module].

  Add:
  - Module/file header
  - Function docstrings
  - Complex logic explanations
  - Type hints (if applicable)"
)

Output​

  • Documentation files
  • Inline comments
  • API specs

Recipe 12: Refactor Existing Code​

Goal: Improve code structure without changing behavior.

Extract Function/Module​

Task(
  subagent_type="senior-architect",
  prompt="refactor [file/function].

  Current issues:
  - [issue 1]
  - [issue 2]

  Goals:
  - Better separation of concerns
  - Improved testability
  - Reduced complexity

  Maintain backward compatibility."
)

Apply Design Pattern​

Task(
  subagent_type="senior-architect",
  prompt="refactor [area] using
  [pattern name] pattern.

  Current code: [description]
  Why this pattern: [reasoning]

  Provide:
  1. Refactored code
  2. Migration steps
  3. Tests to verify behavior unchanged"
)

Output​

  • Refactored code
  • Migration guide
  • Updated tests

Recipe 13: Research a Technology​

Goal: Learn about a technology before using it.

Technology Comparison​

Task(
  subagent_type="research-agent",
  prompt="compare [Option A] vs [Option B]
  for [use case].

  Compare:
  - Features
  - Performance
  - Learning curve
  - Community/support
  - Cost (if applicable)

  Provide a recommendation with reasoning."
)

Best Practices Research​

Task(
  subagent_type="research-agent",
  prompt="research best practices for
  [technology/pattern].

  Looking for:
  - Industry standards
  - Common pitfalls to avoid
  - Real-world examples
  - Recommended tools/libraries"
)

Output​

  • Research summary
  • Comparison tables
  • Recommendations

Recipe 14: Plan a Feature​

Goal: Plan implementation before coding.

Feature Planning​

Task(
  subagent_type="orchestrator",
  prompt="create an implementation plan for
  [feature description].

  Provide:
  1. Requirements breakdown
  2. Technical approach
  3. Task list with estimates
  4. Dependencies
  5. Potential risks
  6. Testing strategy"
)

Architecture Decision​

Task(
  subagent_type="senior-architect",
  prompt="create an ADR (Architecture
  Decision Record) for [decision].

  Context: [why we need to decide]
  Options considered: [list options]
  Constraints: [limitations]

  Provide recommendation with trade-offs."
)

Output​

  • Implementation plan
  • Task breakdown
  • ADR document

Recipe 15: Fix a Security Issue​

Goal: Address security vulnerabilities.

Security Audit​

Task(
  subagent_type="security-specialist",
  prompt="audit [area] for vulnerabilities.

  Check for:
  - OWASP Top 10
  - Authentication/authorization issues
  - Data validation
  - Secrets exposure
  - Dependency vulnerabilities

  Provide fixes for any issues found."
)

Specific Vulnerability Fix​

Task(
  subagent_type="security-specialist",
  prompt="fix [vulnerability type]
  in [file/area].

  Current code: [description]
  Vulnerability: [description]

  Provide:
  1. Secure implementation
  2. Explanation of the fix
  3. Tests to verify security"
)

Output​

  • Vulnerability report
  • Fixed code
  • Security tests

Tips for Using Recipes​

Customize the Placeholders​

Replace [bracketed text] with your specific details. More context = better results.

Chain Recipes Together​

Many projects follow patterns like:

  1. Recipe 1 (Start project)
  2. Recipe 2 (Design database)
  3. Recipe 3 (Create API)
  4. Recipe 5 (Write tests)
  5. Recipe 10 (Deploy)

Ask for Variations​

Add to any recipe: "Also show me an alternative approach" or "What are the trade-offs?"

Save Your Favorites​

Create your own recipes based on patterns you use often.

Recipe 16: Sync Git Changes​

Goal: Automatically sync git changes across submodules.

Full Repository Sync​

/git-sync --target all --mode full

Dry Run Preview​

/git-sync --target all --dry-run

Analysis Only​

/git-sync --mode analyze

Output​

  • All submodules committed and pushed
  • Conventional commit messages generated
  • Master repo pointers updated
  • JSON + Markdown sync report

Recipe 17: Execute Workflow​

Goal: Run automation workflows for common tasks.

List Available Workflows​

/execute-workflow --list

Preview Workflow​

/execute-workflow security-audit --dry-run

Execute with Inputs​

/execute-workflow deploy --input env=prod

Resume from Checkpoint​

/execute-workflow --resume .coditect/workflow-checkpoints/abc123.json

Output​

  • Workflow execution report
  • Checkpoints for resume capability
  • Results for each workflow step

Business, Research & Education Recipes​

CODITECT handles more than software development. The recipes below cover business strategy, market research, competitive intelligence, education, content creation, and other knowledge work.

Recipe 18: Create Market Analysis (Business)​

Goal: Analyze a market with sizing, competition, and opportunities.

Quick Version​

Task(
  subagent_type="business-intelligence-analyst",
  prompt="Create market analysis for [your market/industry]"
)

Comprehensive Version​

Task(
  subagent_type="business-intelligence-analyst",
  prompt="""Create comprehensive market analysis for [market]:

  Required deliverables:
  1. Market sizing (TAM/SAM/SOM with methodology)
  2. Market growth rate and projections (5 year)
  3. Key market segments and characteristics
  4. Buyer personas and purchase drivers
  5. Pricing analysis and elasticity
  6. Market trends and disruption factors
  7. Entry barriers and success factors

  Format: Executive summary + detailed sections
  Include: Charts descriptions, data sources"""
)

Output​

  • Market sizing calculations
  • Growth projections
  • Segment analysis
  • Strategic recommendations

Recipe 19: Competitive Intelligence (Research)​

Goal: Research and analyze competitors.

Quick Version​

Task(
  subagent_type="competitive-market-analyst",
  prompt="Analyze top 5 competitors to [your product/service]"
)

Detailed Version​

Task(
  subagent_type="competitive-market-analyst",
  prompt="""Conduct competitive intelligence for [product/market]:

  Competitors to analyze: [list or 'identify top 5']

  For each competitor, analyze:
  1. Company overview (size, funding, leadership)
  2. Product/service offerings
  3. Pricing strategy and models
  4. Target market and positioning
  5. Strengths and weaknesses
  6. Recent news/developments
  7. Customer reviews/sentiment

  Deliverables:
  - Competitive matrix (features vs competitors)
  - Positioning map
  - SWOT analysis
  - Strategic recommendations"""
)

Output​

  • Competitor profiles
  • Feature comparison matrix
  • Positioning analysis
  • Strategic recommendations

Recipe 20: Business Plan Creation (Strategy)​

Goal: Create a comprehensive business plan.

Quick Version​

Task(
  subagent_type="business-intelligence-analyst",
  prompt="Create business plan for [business description]"
)

Full Business Plan​

Task(
  subagent_type="business-intelligence-analyst",
  prompt="""Create comprehensive business plan for [business]:

  Sections required:
  1. Executive Summary
  2. Company Description & Mission
  3. Market Analysis (TAM/SAM/SOM)
  4. Competitive Analysis
  5. Products/Services Description
  6. Marketing & Sales Strategy
  7. Operations Plan
  8. Management Team
  9. Financial Projections (3-5 years)
     - Revenue model
     - Unit economics
     - P&L projections
     - Cash flow
     - Break-even analysis
  10. Funding Requirements & Use of Funds
  11. Risk Analysis & Mitigation

  Context:
  - Industry: [industry]
  - Stage: [startup/growth/established]
  - Funding target: [amount if applicable]"""
)

Output​

  • Complete business plan document
  • Financial model framework
  • Risk assessment

Recipe 21: Investment Readiness Assessment (Finance)​

Goal: Prepare for fundraising or investment.

Quick Version​

Task(
  subagent_type="venture-capital-business-analyst",
  prompt="Assess Series A readiness for [startup]"
)

Full Assessment​

Task(
  subagent_type="venture-capital-business-analyst",
  prompt="""Conduct investment readiness assessment for [company]:

  Analyze and score (1-10):
  1. Team strength and gaps
  2. Product-market fit evidence
  3. Market opportunity size
  4. Business model scalability
  5. Unit economics health
  6. Growth metrics and trajectory
  7. Competitive moat/differentiation
  8. Financial management
  9. Legal/IP foundation

  Provide:
  - Overall investment readiness score
  - Priority improvements
  - Valuation considerations
  - Investor pitch recommendations
  - Due diligence preparation checklist"""
)

Output​

  • Readiness scorecard
  • Gap analysis
  • Improvement roadmap
  • Pitch recommendations

Recipe 22: Course Curriculum Design (Education)​

Goal: Create educational curriculum or training program.

Quick Version​

Task(
  subagent_type="ai-curriculum-specialist",
  prompt="Design 5-module curriculum for [topic]"
)

Full Curriculum​

Task(
  subagent_type="ai-curriculum-specialist",
  prompt="""Design comprehensive curriculum for [topic]:

  Program details:
  - Target audience: [beginner/intermediate/advanced]
  - Duration: [weeks/hours]
  - Format: [self-paced/instructor-led/hybrid]

  For each module, provide:
  1. Learning objectives (measurable)
  2. Key concepts and topics
  3. Prerequisite knowledge
  4. Lesson outline with timing
  5. Hands-on exercises/projects
  6. Assessment questions (quiz, project)
  7. Resources and references
  8. Success criteria

  Include:
  - Module dependency diagram
  - Assessment rubrics
  - Completion certificate criteria"""
)

Output​

  • Complete curriculum outline
  • Module details
  • Assessments
  • Learning paths

Recipe 23: Assessment & Quiz Creation (Education)​

Goal: Create evaluations, quizzes, or assessments.

Quick Version​

Task(
  subagent_type="assessment-creation-agent",
  prompt="Create 20-question quiz on [topic]"
)

Comprehensive Assessment​

Task(
  subagent_type="assessment-creation-agent",
  prompt="""Create assessment for [topic/course]:

  Assessment type: [quiz/exam/project/rubric]
  Skill level: [beginner/intermediate/advanced]
  Duration: [time limit]

  Question types to include:
  - Multiple choice (10)
  - True/false (5)
  - Short answer (3)
  - Scenario-based (2)

  For each question:
  - Question text
  - Answer options (if applicable)
  - Correct answer
  - Explanation of correct answer
  - Difficulty level (1-5)
  - Learning objective mapped

  Include:
  - Answer key
  - Grading rubric
  - Passing threshold
  - Question bank for randomization"""
)

Output​

  • Complete assessment
  • Answer key
  • Grading rubric
  • Learning objective mapping

Recipe 24: Content Marketing Strategy (Marketing)​

Goal: Create content strategy and editorial calendar.

Quick Version​

Task(
  subagent_type="content-marketing",
  prompt="Create 90-day content plan for [product/brand]"
)

Full Strategy​

Task(
  subagent_type="content-marketing",
  prompt="""Create content marketing strategy for [brand/product]:

  Business context:
  - Industry: [industry]
  - Target audience: [personas]
  - Goals: [awareness/leads/conversion]
  - Channels: [blog, social, email, video]

  Deliverables:
  1. Content pillars and themes
  2. 90-day editorial calendar
     - Blog post topics (12+)
     - Social media content ideas (30+)
     - Email campaigns (4+)
     - Video/podcast topics (4+)
  3. SEO keyword strategy
  4. Content distribution plan
  5. Success metrics and KPIs
  6. Content repurposing strategy
  7. Competitor content analysis"""
)

Output​

  • Content strategy document
  • Editorial calendar
  • SEO keyword list
  • Distribution plan

Recipe 25: Web Research Report (Research)​

Goal: Research and synthesize information from web sources.

Quick Version​

Task(
  subagent_type="web-search-researcher",
  prompt="Research [topic] and summarize key findings"
)

Comprehensive Research​

Task(
  subagent_type="web-search-researcher",
  prompt="""Conduct web research on [topic]:

  Research questions:
  1. [Question 1]
  2. [Question 2]
  3. [Question 3]

  Requirements:
  - Find authoritative sources (academic, industry, official)
  - Verify information across multiple sources
  - Note publication dates and relevance
  - Identify conflicting information

  Deliverables:
  - Executive summary (300 words)
  - Detailed findings per question
  - Source list with credibility assessment
  - Key statistics and data points
  - Areas needing further research"""
)

Output​

  • Research report
  • Source bibliography
  • Key findings summary

Recipe 26: Person/Company Profile (Research)​

Goal: Research and profile a person or company.

Quick Version​

Task(
  subagent_type="biographical-researcher",
  prompt="Create profile for [person/company name]"
)

Detailed Profile​

Task(
  subagent_type="biographical-researcher",
  prompt="""Create comprehensive profile for [subject]:

  For a person:
  - Professional background and career history
  - Current role and responsibilities
  - Education and credentials
  - Notable achievements and projects
  - Publications and media appearances
  - Professional network and affiliations
  - Public statements and positions
  - Social media presence

  For a company:
  - Company overview and history
  - Leadership team profiles
  - Products/services
  - Funding history and investors
  - Key partnerships
  - Market position
  - Recent news and developments
  - Employee reviews/culture

  Cite all sources."""
)

Output​

  • Detailed profile document
  • Key facts summary
  • Source list

Recipe 27: HR Hiring Process (Operations)​

Goal: Design hiring workflow and materials.

Quick Version​

Task(
  subagent_type="orchestrator",
  prompt="Design hiring process for [role]"
)

Complete Hiring Package​

Task(
  subagent_type="orchestrator",
  prompt="""Design complete hiring process for [role]:

  Role context:
  - Department: [department]
  - Level: [junior/mid/senior]
  - Location: [remote/hybrid/onsite]

  Deliverables:
  1. Job description
     - Responsibilities
     - Requirements (must-have vs nice-to-have)
     - Benefits and compensation range
  2. Candidate screening criteria
  3. Interview process (stages)
  4. Interview questions per stage
  5. Technical assessment (if applicable)
  6. Evaluation rubric
  7. Offer letter template
  8. Onboarding checklist (first 90 days)"""
)

Output​

  • Job description
  • Interview guide
  • Assessment rubric
  • Onboarding plan

Recipe 28: Financial Model (Finance)​

Goal: Create financial projections and models.

Quick Version​

Task(
  subagent_type="business-intelligence-analyst",
  prompt="Create 3-year financial model for [business]"
)

Detailed Model​

Task(
  subagent_type="business-intelligence-analyst",
  prompt="""Create financial model for [business]:

  Business model: [SaaS/marketplace/e-commerce/service]
  Current stage: [pre-revenue/revenue/profitable]

  Model components:
  1. Revenue model
     - Pricing tiers
     - Customer acquisition assumptions
     - Churn assumptions
     - Expansion revenue
  2. Cost structure
     - Fixed costs
     - Variable costs
     - CAC and LTV
  3. P&L projection (monthly for Y1, quarterly Y2-3)
  4. Cash flow projection
  5. Key metrics dashboard
     - MRR/ARR
     - Gross margin
     - CAC payback
     - Rule of 40
  6. Scenario analysis (base/bull/bear)
  7. Funding runway calculation

  Format: Spreadsheet structure with formulas explained"""
)

Output​

  • Financial model structure
  • Assumptions documentation
  • Key metrics
  • Scenario analysis

Goal: Create compliance checklist or legal documentation.

Quick Version​

Task(
  subagent_type="orchestrator",
  prompt="Create GDPR compliance checklist for [application]"
)

Comprehensive Compliance​

Task(
  subagent_type="orchestrator",
  prompt="""Create compliance framework for [regulation/standard]:

  Application context:
  - Type: [web app/mobile/SaaS]
  - Data handled: [types of data]
  - Geography: [regions served]

  Deliverables:
  1. Regulatory requirements summary
  2. Compliance checklist with status tracking
  3. Data flow mapping
  4. Required policies list
     - Privacy policy elements
     - Terms of service elements
  5. Technical requirements
  6. Process requirements
  7. Documentation requirements
  8. Audit preparation guide
  9. Risk assessment matrix

  Note: This is guidance only, not legal advice."""
)

Output​

  • Compliance checklist
  • Policy templates
  • Risk assessment

Recipe 30: Project Proposal (Business)​

Goal: Create client or internal project proposal.

Quick Version​

Task(
  subagent_type="orchestrator",
  prompt="Create project proposal for [project description]"
)

Full Proposal​

Task(
  subagent_type="orchestrator",
  prompt="""Create professional project proposal for [project]:

  Context:
  - Client/stakeholder: [name]
  - Project type: [consulting/development/implementation]
  - Budget range: [if known]

  Proposal sections:
  1. Executive Summary
  2. Understanding of Requirements
  3. Proposed Solution/Approach
  4. Scope of Work (in/out of scope)
  5. Deliverables and Milestones
  6. Team and Resources
  7. Timeline (Gantt chart description)
  8. Pricing/Investment
  9. Terms and Conditions
  10. Case Studies/References
  11. Next Steps

  Tone: Professional, client-focused"""
)

Output​

  • Complete proposal document
  • Timeline
  • Pricing structure

Tips for Success​

  • Stuck? Use the first-project-companion agent
  • Not sure which recipe? Ask: cr "I want to [goal]"
  • Recipe not working? Add more context to the prompt
  • Chain recipes for complete workflows (1→2→3→5→10)

How CODITECT Works​

For deeper understanding of the framework mechanics:

TopicDocumentWhat You'll Learn
Component RegistryCOMPONENT-REFERENCE.mdHow 1,857 components are organized, registered, and discovered
Activation SystemCOMPONENT-ACTIVATION-GUIDE.mdWhy components require activation and how to manage state
System ArchitectureARCHITECTURE-OVERVIEW.mdDistributed intelligence, symlink chains, multi-agent coordination
Memory SystemMEMORY-MANAGEMENT-GUIDE.mdAnti-forgetting system, /cx commands, context preservation

Key Files​

config/
├── component-counts.json           # Auto-generated component totals
├── component-activation-status.json # Which components are active
└── framework-registry.json          # Master component catalog

.coditect/
├── component-activation-status.json # Canonical activation state
└── settings.local.json              # Local configuration

Quick Commands​

# View component counts
cat config/component-counts.json

# List activated components
python3 scripts/update-component-activation.py list --activated-only

# Activate a component
python3 scripts/update-component-activation.py activate agent NAME --reason "purpose"

# Update counts after changes
python3 scripts/update-component-counts.py

Further Reading​

Troubleshooting​

Common Recipe Issues​

Agent not recognized:

# Check if agent exists
ls agents/ | grep AGENT_NAME

# Verify activation
python3 scripts/update-component-activation.py status agent AGENT_NAME

# Activate if needed
python3 scripts/update-component-activation.py activate agent AGENT_NAME --reason "Using recipe"

Recipe produces incomplete output:

  • Add more context to your prompt
  • Be specific about expected deliverables
  • Include format requirements (e.g., "Output: docs/analysis.md")
  • Chain multiple recipes for complex tasks

Orchestrator times out:

  • Break complex tasks into smaller phases
  • Use sequential pipeline pattern instead
  • Increase specificity in prompts

Wrong agent selected:

Next Steps​

After mastering these recipes:

  1. Create custom recipes - Build your own patterns for repeated tasks
  2. Explore workflows - WORKFLOW-LIBRARY-INDEX.md for 50+ advanced workflows
  3. Learn orchestration - ARCHITECTURE-OVERVIEW.md for multi-agent patterns
  4. Get certified - USER-TRAINING-PATHWAYS.md for official certification
  5. Contribute recipes - Share your patterns with the CODITECT community

Author: CODITECT Framework Team Framework: CODITECT v1.7.2