Application Developer Partner (ADP)

R&D/Innovation Team
       ↓
  Use Case Creation
       ↓
  Elaboration (Sonnet 4.5)
       ↓
  Modification & Refinement
       ↓
  Development Plan Generation
       ↓
┌──────────────────────────┐
│ Application Developer    │
│      Partner (ADP)       │
├──────────────────────────┤
│ • Project Initialization │
│ • Checkpoint Guidance    │
│ • Time Tracking          │
│ • Quality Gate Enforcement│
│ • Real-time Assistance   │
│ • Progress Reporting     │
└──────────────────────────┘
       ↓
  Developer Execution
       ↓
  Completed Feature

1. Parse development plan
2. Extract all checkpoints
3. Generate project structure
4. Initialize tracking systems
5. Brief developer on approach
6. Confirm understanding

╔═══════════════════════════════════════════════╗
║  Application Developer Partner                ║
║  Project Initialization                       ║
╠═══════════════════════════════════════════════╣
║                                               ║
║  Project: [Git Worktree Manager Skill]       ║
║  Developer: [Kevin Smith]                     ║
║  Priority: [High]                             ║
║  Estimated Duration: 8-12 hours               ║
║                                               ║
║  Development Plan Loaded ✓                    ║
║  Checkpoints Identified: 5                    ║
║  Quality Gates: 4                             ║
║                                               ║
║  Ready to begin?                              ║
║                                               ║
║  [ Start Project ]  [ Review Plan ]           ║
║                                               ║
╚═══════════════════════════════════════════════╝

{
  checkpoint_id: "CP01",
  name: "Problem Definition",
  phase: "pre-development",
  estimated_time: "15-30 minutes",
  required_deliverables: [
    "Problem statement",
    "Input/output specification",
    "Success criteria",
    "Context requirements",
    "User interaction model"
  ],
  quality_checks: [
    "Problem clearly scoped",
    "Success criteria measurable",
    "Context requirements realistic"
  ],
  next_checkpoint: "CP02",
  guidance_prompts: [
    "What problem are you solving?",
    "Who is the user?",
    "What does success look like?"
  ]
}

┌─────────────────────────────────────┐
│ Checkpoint 1: Problem Definition    │
├─────────────────────────────────────┤
│ Status: In Progress                 │
│ Time Elapsed: 12 minutes            │
│ Estimated Remaining: 3-18 minutes   │
├─────────────────────────────────────┤
│                                     │
│ Required Deliverables:              │
│ ✓ Problem statement                 │
│ ✓ Input/output spec                 │
│ ○ Success criteria                  │
│ ○ Context requirements              │
│ ○ User interaction model            │
│                                     │
│ Current Task:                       │
│ Define success criteria             │
│                                     │
│ Guidance:                           │
│ "Success criteria should be:        │
│  - Measurable                       │
│  - Specific                         │
│  - Testable                         │
│  - Aligned with business goals"     │
│                                     │
│ [ Need Help ] [ Mark Complete ]     │
│                                     │
└─────────────────────────────────────┘

{
  project_id: "PRJ-2024-045",
  developer_id: "DEV-KS",
  timestamps: {
    project_start: "2024-11-09T09:00:00Z",
    checkpoint_times: [
      {
        checkpoint_id: "CP01",
        start: "2024-11-09T09:00:00Z",
        end: "2024-11-09T09:28:00Z",
        duration_minutes: 28,
        estimated_minutes: 22.5,
        variance_minutes: 5.5,
        variance_percentage: 24.4
      },
      // ... more checkpoints
    ]
  },
  activity_breakdown: {
    planning: 45,
    coding: 180,
    debugging: 65,
    documentation: 32,
    testing: 28
  },
  interruptions: [
    {
      timestamp: "2024-11-09T10:15:00Z",
      duration_minutes: 12,
      reason: "meeting"
    }
  ]
}

╔═══════════════════════════════════════════════╗
║  Time Analytics Dashboard                     ║
╠═══════════════════════════════════════════════╣
║                                               ║
║  Project Progress: ████████░░ 80%             ║
║  Time Elapsed: 6.5 hours / 8 estimated        ║
║  Projected Completion: 8.2 hours              ║
║                                               ║
║  Checkpoint Performance:                      ║
║  CP01: 28 min (est 22.5) +24% ⚠️              ║
║  CP02: 95 min (est 90)   +6%  ✓               ║
║  CP03: 18 min (est 30)   -40% ✓✓              ║
║  CP04: In Progress...                         ║
║                                               ║
║  Activity Breakdown:                          ║
║  Planning:       45 min (13%)                 ║
║  Coding:        180 min (51%)                 ║
║  Debugging:      65 min (19%)                 ║
║  Documentation:  32 min (9%)                  ║
║  Testing:        28 min (8%)                  ║
║                                               ║
║  Efficiency Score: 87/100                     ║
║                                               ║
╚═══════════════════════════════════════════════╝

{
  gate_id: "QG01",
  gate_name: "Checkpoint Completion",
  trigger: "checkpoint_marked_complete",
  checks: [
    {
      check_id: "deliverables_complete",
      description: "All required deliverables present",
      automated: true,
      blocking: true
    },
    {
      check_id: "quality_checklist",
      description: "Quality checklist items verified",
      automated: true,
      blocking: true
    },
    {
      check_id: "time_variance_acceptable",
      description: "Time variance within acceptable range",
      automated: true,
      blocking: false,
      warning_threshold: 50
    }
  ],
  on_failure: "prevent_progression",
  remediation_guidance: [
    "Review missing deliverables",
    "Complete all checklist items",
    "Document reasons for time variance"
  ]
}

{
  gate_id: "QG02",
  gate_name: "Peer Review Required",
  trigger: "checkpoint_03_complete",
  checks: [
    {
      check_id: "reviewer_assigned",
      description: "Peer reviewer assigned",
      automated: false,
      blocking: true
    },
    {
      check_id: "review_completed",
      description: "Peer review completed",
      automated: false,
      blocking: true
    },
    {
      check_id: "feedback_addressed",
      description: "Review feedback incorporated",
      automated: false,
      blocking: true
    }
  ],
  notification_channels: ["slack", "email"],
  timeout_hours: 24,
  escalation_after_timeout: "team_lead"
}

{
  gate_id: "QG03",
  gate_name: "Integration Testing",
  trigger: "checkpoint_05_complete",
  checks: [
    {
      check_id: "unit_tests_pass",
      description: "All unit tests passing",
      automated: true,
      blocking: true,
      command: "npm run test:unit"
    },
    {
      check_id: "integration_tests_pass",
      description: "All integration tests passing",
      automated: true,
      blocking: true,
      command: "npm run test:integration"
    },
    {
      check_id: "code_coverage",
      description: "Code coverage meets threshold",
      automated: true,
      blocking: true,
      threshold: 80
    }
  ]
}

{
  gate_id: "QG04",
  gate_name: "Documentation Completeness",
  trigger: "pre_deployment",
  checks: [
    {
      check_id: "readme_present",
      description: "README.md exists and complete",
      automated: true,
      blocking: true
    },
    {
      check_id: "skill_md_complete",
      description: "SKILL.md follows template",
      automated: true,
      blocking: true,
      template_path: "templates/SKILL_template.md"
    },
    {
      check_id: "examples_provided",
      description: "Usage examples documented",
      automated: true,
      blocking: true,
      minimum_examples: 2
    }
  ]
}

╔═══════════════════════════════════════════════╗
║  ⚠️  QUALITY GATE: Checkpoint Completion      ║
╠═══════════════════════════════════════════════╣
║                                               ║
║  Cannot proceed to next checkpoint.           ║
║                                               ║
║  Missing Requirements:                        ║
║  ✗ Success criteria not defined               ║
║  ✗ Context requirements incomplete            ║
║                                               ║
║  Warnings:                                    ║
║  ⚠️  Time variance: +65% (acceptable: <50%)   ║
║     Document reason for overrun               ║
║                                               ║
║  Action Required:                             ║
║  1. Complete success criteria                 ║
║  2. Finish context requirements               ║
║  3. Document time variance reason             ║
║                                               ║
║  [ View Requirements ] [ Get Help ]           ║
║                                               ║
╚═══════════════════════════════════════════════╝

Developer Action: Starts creating a skill
ADP Response: 
"⚠️  METHODOLOGY CHECK
Have you created and tested a custom slash command first?

The protocol requires:
1. ✓ Create slash command
2. ✓ Test and validate
3. ○ Consider skill advancement

Would you like to:
[Create Slash Command First] [I Have One] [Explain Why]"

Developer Action: Writes skill that reimplements logic
ADP Response:
"🔍 COMPOSITION OPPORTUNITY DETECTED

Your skill appears to reimplement logic.
Consider using slash command tool instead:

Current approach:
- Writing 45 lines of new prompt logic

Better approach:
- Use existing /create-worktree command
- Skill becomes orchestrator

Would you like help refactoring?"

Developer Action: Creates nested sub-agent structure
ADP Response:
"❌ ANTI-PATTERN DETECTED

Sub-agents cannot invoke other sub-agents.

Detected: sub-agent-A → sub-agent-B

This violates the compositional rules.

Suggested fix:
- Have both sub-agents call the same slash command
- Use skill to orchestrate if needed

[View Documentation] [Refactor Now] [Ignore Warning]"

Developer Action: Adds 3rd MCP server
ADP Response:
"⚠️  CONTEXT WINDOW ALERT

Current usage: 15,250 tokens (76% capacity)
Adding MCP server will increase to ~18,500 tokens (93%)

Recommendations:
- Remove unused MCP servers
- Consider sub-agent isolation
- Review progressive disclosure

Continue anyway? [Yes] [Optimize First] [Analyze Impact]"

╔═══════════════════════════════════════════════╗
║  Feature Selection Wizard                     ║
╠═══════════════════════════════════════════════╣
║                                               ║
║  Let's determine the right approach...        ║
║                                               ║
║  Question 1 of 6:                             ║
║                                               ║
║  Is this a one-off task or recurring?         ║
║                                               ║
║  ○ One-off task                               ║
║  ○ Recurring workflow                         ║
║  ○ Not sure                                   ║
║                                               ║
║  [ Back ] [ Next ]                            ║
║                                               ║
╚═══════════════════════════════════════════════╝

[After answering all questions]

╔═══════════════════════════════════════════════╗
║  Recommendation                               ║
╠═══════════════════════════════════════════════╣
║                                               ║
║  Based on your answers:                       ║
║                                               ║
║  ✓ Recurring workflow                         ║
║  ✓ Needs agent autonomy                       ║
║  ✓ Multiple related operations                ║
║  ✓ No external integrations                   ║
║  ✗ No parallelization needed                  ║
║                                               ║
║  RECOMMENDATION:                              ║
║  🎯 Build an AGENT SKILL                      ║
║                                               ║
║  Required components:                         ║
║  • 3 custom slash commands                    ║
║  • 1 skill to orchestrate                     ║
║                                               ║
║  Start with:                                  ║
║  1. Create /command-1                         ║
║  2. Create /command-2                         ║
║  3. Create /command-3                         ║
║  4. Build skill that composes them            ║
║                                               ║
║  [ Start Development ] [ Explain More ]       ║
║                                               ║
╚═══════════════════════════════════════════════╝

═══════════════════════════════════════════════
DAILY DEVELOPMENT SUMMARY
Developer: Kevin Smith
Date: 2024-11-09
Project: Git Worktree Manager Skill
═══════════════════════════════════════════════

PROGRESS
--------
Checkpoints Completed: 3/5 (60%)
Time Invested: 6.5 hours
Estimated Remaining: 2-4 hours

COMPLETED TODAY
---------------
✓ Problem Definition (28 min)
✓ Custom Slash Command Creation (95 min)
✓ Feature Advancement Decision (18 min)

IN PROGRESS
-----------
→ Advanced Feature Build (Currently 3h 12m)
  - Skill structure created
  - 2/3 commands integrated
  - Testing in progress

NEXT UP
-------
- Complete skill integration
- Integration & Testing checkpoint
- Quality gate reviews

METRICS
-------
Efficiency Score: 87/100
Time Variance: +8% (within acceptable range)
Quality Gates Passed: 3/3

BLOCKERS
--------
None

NOTES
-----
Time overrun on Checkpoint 1 due to additional
stakeholder clarifications. Compensated with
faster Checkpoint 3 completion. On track for
end-of-day delivery.

═══════════════════════════════════════════════

═══════════════════════════════════════════════
PROJECT COMPLETION REPORT
Project: Git Worktree Manager Skill
Developer: Kevin Smith
Completion Date: 2024-11-09
═══════════════════════════════════════════════

EXECUTIVE SUMMARY
-----------------
✓ Project completed successfully
✓ All quality gates passed
✓ Documentation complete
✓ Within 10% of time estimate

TIMELINE
--------
Start: 2024-11-09 09:00 AM
End: 2024-11-09 05:45 PM
Duration: 8 hours 45 minutes
Estimate: 8-12 hours
Variance: +9% (acceptable)

DELIVERABLES
------------
✓ 3 Custom Slash Commands
  - /create-worktree
  - /list-worktrees
  - /merge-worktree

✓ 1 Agent Skill
  - worktree-manager
  - Composes all 3 commands
  - Autonomous operation validated

✓ Complete Documentation
  - SKILL.md (follows template)
  - README.md
  - Usage examples (3 provided)

✓ Testing
  - Unit tests: 12/12 passing
  - Integration tests: 8/8 passing
  - Code coverage: 87%

QUALITY METRICS
---------------
Efficiency Score: 87/100
Code Quality: A
Documentation Quality: A
Test Coverage: 87% (target: 80%)

CHECKPOINT BREAKDOWN
--------------------
CP01: Problem Definition (28 min, +24%)
CP02: Slash Command Creation (95 min, +6%)
CP03: Feature Decision (18 min, -40%)
CP04: Skill Build (245 min, +12%)
CP05: Integration & Testing (139 min, +8%)

TIME ANALYSIS
-------------
Planning: 46 min (9%)
Coding: 312 min (59%)
Testing: 95 min (18%)
Documentation: 52 min (10%)
Review: 20 min (4%)

LEARNINGS
---------
- Checkpoint 1 overrun due to unclear requirements
- Checkpoint 3 completed faster than expected
- Integration testing revealed edge case (fixed)
- Documentation template very helpful

RECOMMENDATIONS
---------------
- Update time estimate for slash command creation (+10%)
- Add edge case testing to standard checklist
- Consider creating worktree testing sub-skill

APPROVAL
--------
Developer: Kevin Smith ✓
Peer Reviewer: Jane Doe ✓
Technical Lead: John Smith ✓
Ready for Deployment: Yes

═══════════════════════════════════════════════

═══════════════════════════════════════════════
TEAM ANALYTICS REPORT
Period: November 2024
Team: Repeatable AI Development
═══════════════════════════════════════════════

PROJECTS COMPLETED: 12

AVERAGE METRICS
---------------
Efficiency Score: 84/100
Time Variance: +12% (improving, was +18%)
Quality Gates First-Pass: 87%

CHECKPOINT PERFORMANCE
----------------------
CP01: Avg 26 min (est 22.5) = +16%
CP02: Avg 102 min (est 90) = +13%
CP03: Avg 25 min (est 30) = -17%
CP04: Avg 268 min (est 240) = +12%
CP05: Avg 142 min (est 135) = +5%

MOST COMMON BOTTLENECKS
-----------------------
1. Requirements clarification (Checkpoint 1)
2. Integration testing (Checkpoint 5)
3. Peer review availability (Quality Gate 2)

ESTIMATION ACCURACY TREND
-------------------------
January:   ±35%
February:  ±28%
March:     ±22%
...
November:  ±12% ← Current

DEVELOPER PERFORMANCE
---------------------
Kevin Smith:    89/100 (6 projects)
Jane Doe:       91/100 (4 projects)
John Smith:     82/100 (2 projects)

SKILL DISTRIBUTION
------------------
Projects using Skills: 8/12 (67%)
Projects using MCP: 5/12 (42%)
Projects using Sub-Agents: 3/12 (25%)
Average Slash Commands: 4.2 per project

METHODOLOGY COMPLIANCE
----------------------
Started with Slash Command: 100% ✓
Proper Feature Selection: 92%
Documentation Complete: 100% ✓
Anti-Patterns Detected: 2 (both fixed)

RECOMMENDATIONS
---------------
- Continue focus on requirements clarity
- Consider dedicated peer review slots
- Update time estimates for CP02 (+10%)
- Celebrate improvements in estimation accuracy

═══════════════════════════════════════════════

-- Projects table
CREATE TABLE projects (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name VARCHAR(255) NOT NULL,
  description TEXT,
  technical_spec_url TEXT,
  development_plan_url TEXT,
  developer_id UUID REFERENCES developers(id),
  status VARCHAR(50) NOT NULL,
  priority VARCHAR(20),
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  started_at TIMESTAMP,
  completed_at TIMESTAMP,
  estimated_hours DECIMAL(5,2),
  actual_hours DECIMAL(5,2)
);

-- Checkpoints table
CREATE TABLE checkpoints (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  project_id UUID REFERENCES projects(id),
  checkpoint_number INTEGER NOT NULL,
  name VARCHAR(255) NOT NULL,
  phase VARCHAR(50),
  status VARCHAR(50) NOT NULL,
  estimated_minutes INTEGER,
  actual_minutes INTEGER,
  started_at TIMESTAMP,
  completed_at TIMESTAMP,
  deliverables JSONB,
  quality_checks JSONB,
  notes TEXT
);

-- Quality gates table
CREATE TABLE quality_gates (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  project_id UUID REFERENCES projects(id),
  gate_id VARCHAR(50) NOT NULL,
  gate_name VARCHAR(255) NOT NULL,
  status VARCHAR(50) NOT NULL,
  triggered_at TIMESTAMP,
  completed_at TIMESTAMP,
  checks_passed INTEGER,
  checks_failed INTEGER,
  check_details JSONB,
  remediation_actions JSONB
);

-- Time tracking table
CREATE TABLE time_entries (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  project_id UUID REFERENCES projects(id),
  checkpoint_id UUID REFERENCES checkpoints(id),
  developer_id UUID REFERENCES developers(id),
  activity_type VARCHAR(50),
  start_time TIMESTAMP NOT NULL,
  end_time TIMESTAMP,
  duration_minutes INTEGER,
  notes TEXT,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Interruptions table
CREATE TABLE interruptions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  time_entry_id UUID REFERENCES time_entries(id),
  start_time TIMESTAMP NOT NULL,
  end_time TIMESTAMP NOT NULL,
  duration_minutes INTEGER,
  reason VARCHAR(255),
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Features table (slash commands, skills, etc.)
CREATE TABLE features (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  project_id UUID REFERENCES projects(id),
  feature_type VARCHAR(50) NOT NULL, -- 'slash_command', 'skill', 'mcp', 'sub_agent'
  name VARCHAR(255) NOT NULL,
  description TEXT,
  file_path TEXT,
  composed_features JSONB, -- IDs of other features this uses
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Decisions table
CREATE TABLE decisions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  project_id UUID REFERENCES projects(id),
  checkpoint_id UUID REFERENCES checkpoints(id),
  decision_type VARCHAR(50),
  question TEXT,
  answer TEXT,
  rationale TEXT,
  alternatives_considered JSONB,
  decided_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  decided_by UUID REFERENCES developers(id)
);

-- AI assistance log table
CREATE TABLE ai_assistance_log (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  project_id UUID REFERENCES projects(id),
  checkpoint_id UUID REFERENCES checkpoints(id),
  assistance_type VARCHAR(50), -- 'guidance', 'warning', 'anti-pattern', etc.
  trigger_event TEXT,
  ai_response TEXT,
  developer_action VARCHAR(50), -- 'accepted', 'ignored', 'modified'
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Developers table
CREATE TABLE developers (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name VARCHAR(255) NOT NULL,
  email VARCHAR(255) UNIQUE NOT NULL,
  skill_level VARCHAR(50),
  efficiency_score DECIMAL(5,2),
  projects_completed INTEGER DEFAULT 0,
  average_variance_percentage DECIMAL(5,2),
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Analytics aggregates table
CREATE TABLE analytics_aggregates (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  period VARCHAR(20), -- 'daily', 'weekly', 'monthly'
  period_start DATE NOT NULL,
  period_end DATE NOT NULL,
  metric_name VARCHAR(100),
  metric_value DECIMAL(10,2),
  additional_data JSONB,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

POST   /api/projects                    # Create new project
GET    /api/projects/:id                # Get project details
PUT    /api/projects/:id                # Update project
GET    /api/projects                    # List all projects
DELETE /api/projects/:id                # Archive project

POST   /api/projects/:id/checkpoints/start       # Start checkpoint
POST   /api/projects/:id/checkpoints/:cpId/complete # Complete checkpoint
GET    /api/projects/:id/checkpoints/:cpId       # Get checkpoint details
PUT    /api/projects/:id/checkpoints/:cpId       # Update checkpoint

POST   /api/time/start                  # Start time tracking
POST   /api/time/stop                   # Stop time tracking
POST   /api/time/interrupt              # Log interruption
GET    /api/projects/:id/time           # Get time analytics

POST   /api/quality-gates/check         # Run quality gate check
GET    /api/projects/:id/gates          # Get gate status
POST   /api/quality-gates/:id/override  # Override gate (with approval)

POST   /api/ai/guidance                 # Get contextual guidance
POST   /api/ai/decision                 # Get decision support
POST   /api/ai/analyze                  # Analyze code/approach
GET    /api/ai/suggestions              # Get proactive suggestions

GET    /api/reports/daily/:developerId  # Daily summary
GET    /api/reports/project/:projectId  # Project report
GET    /api/reports/team                # Team analytics
GET    /api/reports/historical          # Historical trends

// Developer actions
socket.emit('checkpoint:start', { projectId, checkpointId });
socket.emit('checkpoint:deliverable:complete', { checkpointId, deliverableId });
socket.emit('decision:made', { projectId, decision });
socket.emit('code:changed', { projectId, filePath, changeType });

// Request assistance
socket.emit('help:request', { projectId, checkpointId, context });

// Progress updates
socket.emit('checkpoint:progress', { checkpointId, progress });
socket.emit('time:update', { elapsed, estimated, variance });

// Quality gate events
socket.emit('gate:triggered', { gateId, gateName });
socket.emit('gate:passed', { gateId });
socket.emit('gate:failed', { gateId, failures });

// AI assistance
socket.emit('ai:guidance', { message, type, actions });
socket.emit('ai:warning', { message, severity, recommendation });
socket.emit('ai:suggestion', { message, code, explanation });

// Notifications
socket.emit('notification', { type, message, priority });

You are the Application Developer Partner (ADP), an AI assistant helping developers
follow Repeatable AI's Claude Code Development Protocol.

Your role is to:
- Guide developers through checkpoints
- Enforce methodology compliance
- Detect anti-patterns and provide corrections
- Offer best practice recommendations
- Answer questions about the protocol

Context:
- Current Project: {project_name}
- Current Checkpoint: {checkpoint_name}
- Developer: {developer_name}
- Project Progress: {progress_percentage}%

Available Knowledge:
- Complete SOP document
- Project development plan
- Historical project data
- Developer's past performance

Guidelines:
- Be concise and actionable
- Reference specific SOP sections when relevant
- Provide code examples when helpful
- Detect deviations from protocol early
- Balance guidance with developer autonomy
- Use emojis for visual categorization (✓ ⚠️ ❌ 🎯)

Current Status:
{current_status_context}

Analyze the following code/approach:
{code_or_approach}

Check for these anti-patterns:
1. Skill Everything - converting all slash commands to skills unnecessarily
2. Reimplementing in Skills - rewriting logic instead of composing
3. MCP Overuse - using MCP for internal workflows
4. Sub-Agent Chains - trying to have sub-agents invoke other sub-agents
5. Premature Abstraction - building skills before validating with slash commands

If any anti-patterns detected, respond with:
- Pattern name
- Specific violation
- Why it's problematic
- Concrete fix recommendation
- Relevant SOP section

If no anti-patterns, confirm compliance with methodology.

The developer needs to choose between features for this use case:
{use_case_description}

Their answers to the decision tree:
{decision_tree_answers}

Based on the SOP's Feature Decision Matrix:
1. Evaluate each answer
2. Determine the correct feature type
3. Explain the reasoning
4. List required components
5. Provide next steps

Format response as:
RECOMMENDATION: [Feature Type]
REASONING: [Why this feature]
REQUIRED COMPONENTS: [List]
NEXT STEPS: [Actionable items]

The developer is working on Checkpoint {checkpoint_number}: {checkpoint_name}

Current status:
- Time elapsed: {time_elapsed}
- Estimated time: {estimated_time}
- Deliverables completed: {completed_deliverables}
- Deliverables remaining: {remaining_deliverables}

Based on the checkpoint requirements in the SOP:
1. Assess current progress
2. Identify any missing critical items
3. Provide specific next action
4. Offer relevant examples or templates
5. Estimate time to completion

Be encouraging but realistic about progress.

╔═══════════════════════════════════════════════════════════════════╗
║  Application Developer Partner                    Kevin Smith ▼   ║
╠═══════════════════════════════════════════════════════════════════╣
║                                                                    ║
║  Active Project: Git Worktree Manager Skill                       ║
║  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ║
║                                                                    ║
║  Progress: ████████████████░░░░░░░░ 60% (Checkpoint 3 of 5)      ║
║                                                                    ║
║  ┌─────────────────────────────────────────────────────────────┐ ║
║  │ Current Checkpoint: Advanced Feature Build                  │ ║
║  │                                                              │ ║
║  │ Status: In Progress                                          │ ║
║  │ Time: 3h 12m / 4-6h estimated                                │ ║
║  │                                                              │ ║
║  │ Deliverables:                                                │ ║
║  │ ✓ Proper directory structure                                 │ ║
║  │ ✓ Complete documentation                                     │ ║
║  │ ⊙ Composition of existing primitives (75% complete)          │ ║
║  │ ○ Integration tests                                          │ ║
║  │ ○ Usage examples                                             │ ║
║  │                                                              │ ║
║  │ [ Mark Complete ] [ Need Help ] [ View Plan ]                │ ║
║  └─────────────────────────────────────────────────────────────┘ ║
║                                                                    ║
║  ┌─────────────────────────────────────────────────────────────┐ ║
║  │ 🤖 AI Assistant                                              │ ║
║  │                                                              │ ║
║  │ "Great progress on your skill build! I noticed you're       │ ║
║  │  composing slash commands. That's the right approach.       │ ║
║  │                                                              │ ║
║  │  Tip: Don't forget to add error handling for each composed  │ ║
║  │  command. See SOP Section 8.2 for patterns."                │ ║
║  │                                                              │ ║
║  │ [ Ask Question ] [ Show Example ] [ Dismiss ]                │ ║
║  └─────────────────────────────────────────────────────────────┘ ║
║                                                                    ║
║  Quick Stats                         Efficiency Score: 87/100     ║
║  ├─ Time Today: 6h 32m                                            ║
║  ├─ Checkpoints Done: 3                                           ║
║  ├─ Quality Gates Passed: 3/3                                     ║
║  └─ Projected Completion: Today 5:30 PM                           ║
║                                                                    ║
║  [ View Timeline ] [ Analytics ] [ Reports ] [ Settings ]         ║
║                                                                    ║
╚═══════════════════════════════════════════════════════════════════╝

╔═══════════════════════════════════════════════════════════════════╗
║  Feature Selection Decision Support                               ║
╠═══════════════════════════════════════════════════════════════════╣
║                                                                    ║
║  📋 Use Case: Create reusable git worktree operations             ║
║                                                                    ║
║  ┌─────────────────────────────────────────────────────────────┐ ║
║  │ Decision Tree Progress: ████████░░ 80%                       │ ║
║  └─────────────────────────────────────────────────────────────┘ ║
║                                                                    ║
║  Question 4 of 5:                                                  ║
║                                                                    ║
║  Does this need to connect to external services or APIs?           ║
║                                                                    ║
║  ○ Yes, requires external integration                              ║
║  ● No, internal only                                               ║
║  ○ Not sure                                                        ║
║                                                                    ║
║  💡 Need help deciding?                                            ║
║  External services include: APIs, databases, third-party tools,    ║
║  remote systems. Git operations are internal to your codebase.     ║
║                                                                    ║
║  [ ← Back ] [ Next → ]                                             ║
║                                                                    ║
║  ─────────────────────────────────────────────────────────────    ║
║                                                                    ║
║  Your Answers So Far:                                              ║
║  ✓ Task is recurring                                               ║
║  ✓ Needs agent autonomy                                            ║
║  ✓ Multiple related operations                                     ║
║  ✓ No external services needed                                     ║
║                                                                    ║
╚═══════════════════════════════════════════════════════════════════╝

[After completion]

╔═══════════════════════════════════════════════════════════════════╗
║  🎯 Feature Recommendation                                         ║
╠═══════════════════════════════════════════════════════════════════╣
║                                                                    ║
║  Based on your use case analysis, I recommend:                     ║
║                                                                    ║
║  ┌─────────────────────────────────────────────────────────────┐ ║
║  │                                                              │ ║
║  │          🎯 BUILD AN AGENT SKILL                             │ ║
║  │                                                              │ ║
║  │  Confidence: 95%                                             │ ║
║  │                                                              │ ║
║  └─────────────────────────────────────────────────────────────┘ ║
║                                                                    ║
║  Why this recommendation:                                          ║
║  ✓ Recurring workflow requiring automation                         ║
║  ✓ Multiple related operations to manage                           ║
║  ✓ Agent autonomy provides clear value                             ║
║  ✓ No external integrations needed                                 ║
║  ✓ Context efficiency important                                    ║
║                                                                    ║
║  Development Plan:                                                 ║
║                                                                    ║
║  Phase 1: Create Custom Slash Commands                             ║
║  ├─ /create-worktree (2h estimated)                                ║
║  ├─ /list-worktrees (1h estimated)                                 ║
║  └─ /merge-worktree (2h estimated)                                 ║
║                                                                    ║
║  Phase 2: Build Agent Skill                                        ║
║  ├─ Create skill structure (30m estimated)                         ║
║  ├─ Compose slash commands (1h estimated)                          ║
║  ├─ Write SKILL.md (45m estimated)                                 ║
║  └─ Test autonomous invocation (1h estimated)                      ║
║                                                                    ║
║  Total Estimated Time: 8-10 hours                                  ║
║                                                                    ║
║  [ Start Development ] [ Explain More ] [ Alternative Approach ]   ║
║                                                                    ║
╚═══════════════════════════════════════════════════════════════════╝

# Application
APP_NAME=application-developer-partner
APP_ENV=production
APP_PORT=3000
APP_URL=https://adp.repeatable.ai

# Database
DATABASE_URL=postgresql://user:pass@host:5432/adp_db
REDIS_URL=redis://host:6379

# Anthropic API
ANTHROPIC_API_KEY=sk-ant-xxxxx
ANTHROPIC_MODEL=claude-sonnet-4-5-20250929

# Authentication
JWT_SECRET=xxxxx
SESSION_SECRET=xxxxx

# Monitoring
DATADOG_API_KEY=xxxxx
SENTRY_DSN=xxxxx

# Notifications
SLACK_WEBHOOK_URL=xxxxx
EMAIL_SERVICE_API_KEY=xxxxx

version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://postgres:password@db:5432/adp
      - REDIS_URL=redis://redis:6379
    depends_on:
      - db
      - redis
    volumes:
      - ./src:/app/src
    command: npm run dev

  db:
    image: postgres:15
    environment:
      - POSTGRES_DB=adp
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  redis:
    image: redis:7
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

volumes:
  postgres_data:
  redis_data:

// Initialize a new project
const project = await fetch('/api/projects', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    name: 'Git Worktree Manager',
    developerId: 'dev-123',
    technicalSpecUrl: 'https://...',
    developmentPlanUrl: 'https://...'
  })
});

// Start a checkpoint
await fetch(`/api/projects/${projectId}/checkpoints/start`, {
  method: 'POST',
  body: JSON.stringify({
    checkpointNumber: 1
  })
});

// Get AI guidance
const guidance = await fetch('/api/ai/guidance', {
  method: 'POST',
  body: JSON.stringify({
    projectId,
    checkpointId,
    context: {
      currentTask: 'Creating slash command',
      code: '...',
      question: 'Should this be a skill or slash command?'
    }
  })
});