claudetools/AUTOCODER_INTEGRATION.md

AutoCoder Resources Integration Guide

Date: 2026-01-17 Source: AutoCoder project (Autocode-remix fork) Status: Successfully integrated

---

Overview

This guide documents the AutoCoder resources that have been integrated into ClaudeTools, including commands, skills, templates, and an MCP server for feature management.

What was extracted:

• 2 Commands (create-spec, checkpoint)
• 1 Skill (frontend-design)
• 4 Templates (app spec, coding prompts, initializer)
• 1 MCP Server (feature management)

Purpose: Enable autonomous coding workflows with spec-driven development and feature tracking.

---

Directory Structure

D:\ClaudeTools/
├── .claude/
│   ├── commands/
│   │   ├── sync.md              # EXISTING - Cross-machine sync
│   │   ├── create-spec.md       # NEW - Create app specification
│   │   └── checkpoint.md        # NEW - Create development checkpoint
│   │
│   ├── skills/
│   │   └── frontend-design/     # NEW - Frontend design skill
│   │       ├── SKILL.md
│   │       └── LICENSE.txt
│   │
│   └── templates/               # NEW directory
│       ├── app_spec.template.txt
│       ├── coding_prompt.template.md
│       ├── coding_prompt_yolo.template.md
│       └── initializer_prompt.template.md
│
└── mcp-servers/                 # NEW directory
    └── feature-management/
        ├── feature_mcp.py       # MCP server implementation
        ├── __init__.py
        ├── README.md            # Documentation
        └── config.example.json  # Configuration example

---

1. Commands

create-spec.md

Purpose: Create a comprehensive application specification for autonomous coding

How to use:

# In Claude Code
/create-spec

# Claude will guide you through creating:
# - Project overview
# - Tech stack
# - Features list
# - Database schema
# - API endpoints
# - UI/UX requirements

Output: Creates APP_SPEC.md in project root with full specification

When to use:

• Starting a new autonomous coding project
• Documenting requirements for an agent-driven build
• Creating structured input for the feature management system

File location: D:\ClaudeTools\.claude\commands\create-spec.md

---

checkpoint.md

Purpose: Create a detailed development checkpoint with commit and summary

How to use:

# In Claude Code
/checkpoint

# Claude will:
# 1. Analyze recent changes
# 2. Create a detailed commit message
# 3. Commit changes with co-authorship
# 4. Save session context to context recall system

Output:

• Git commit with detailed message
• Context saved to conversation_contexts table
• Decision logged in decision_logs table

When to use:

• After completing a feature
• Before switching to a different task
• At natural breakpoints in development

File location: D:\ClaudeTools\.claude\commands\checkpoint.md

---

2. Skills

frontend-design

Purpose: Specialized skill for creating modern, production-ready frontend designs

How to use:

# In Claude Code
/frontend-design

# Claude will use the skill to:
# - Design responsive layouts
# - Create component hierarchies
# - Implement modern UI patterns
# - Follow accessibility best practices

Features:

• Modern framework patterns (React, Vue, Svelte)
• Responsive design (mobile-first)
• Accessibility (ARIA, semantic HTML)
• Performance optimization
• Component reusability

File location: D:\ClaudeTools\.claude\skills\frontend-design\

---

3. Templates

app_spec.template.txt

Purpose: Template for creating application specifications

Usage: Used by /create-spec command to structure the output

Contents:

• Project metadata
• Technology stack
• Feature categories
• Database schema
• API endpoints
• Authentication/authorization
• Deployment requirements

File location: D:\ClaudeTools\.claude\templates\app_spec.template.txt

---

coding_prompt.template.md

Purpose: Standard coding prompt for autonomous agents

Usage: Structured prompt that defines:

• Agent role and capabilities
• Development workflow
• Quality standards
• Testing requirements
• Error handling patterns

When to use: Starting an autonomous coding agent session

File location: D:\ClaudeTools\.claude\templates\coding_prompt.template.md

---

coding_prompt_yolo.template.md

Purpose: Aggressive "move fast" coding prompt for rapid prototyping

Usage: Alternative prompt that prioritizes:

• Speed over perfect code
• Getting features working quickly
• Minimal testing (just basics)
• Iterative refinement

When to use:

• Proof of concepts
• Rapid prototyping
• MVP development
• Hackathons

File location: D:\ClaudeTools\.claude\templates\coding_prompt_yolo.template.md

---

initializer_prompt.template.md

Purpose: Prompt for initializing a new project from specification

Usage: Sets up:

• Project structure
• Dependencies
• Configuration files
• Initial feature list
• Database setup

When to use: Starting a new project from an APP_SPEC.md

File location: D:\ClaudeTools\.claude\templates\initializer_prompt.template.md

---

4. MCP Server - Feature Management

Overview

The Feature Management MCP Server provides native Claude Code integration for managing autonomous coding workflows with a priority-based feature queue.

Setup

Step 1: Install Dependencies

# Activate ClaudeTools virtual environment
D:\ClaudeTools\venv\Scripts\activate

# Install required packages
pip install fastmcp sqlalchemy pydantic

Step 2: Configure Claude Desktop

Edit Claude Desktop config file:

• Windows: %APPDATA%\Claude\claude_desktop_config.json
• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Linux: ~/.config/claude/claude_desktop_config.json

Add this configuration:

{
  "mcpServers": {
    "features": {
      "command": "python",
      "args": ["D:\\ClaudeTools\\mcp-servers\\feature-management\\feature_mcp.py"],
      "env": {
        "PROJECT_DIR": "D:\\ClaudeTools\\projects\\your-project"
      }
    }
  }
}

Step 3: Restart Claude Desktop

Close and reopen Claude Desktop for changes to take effect.

Step 4: Verify Installation

In Claude Code, you should now have access to these MCP tools:

• feature_get_stats
• feature_get_next
• feature_mark_passing
• feature_mark_in_progress
• feature_skip
• feature_clear_in_progress
• feature_get_for_regression
• feature_create_bulk

---

MCP Server Tools Reference

Quick Reference:

Tool	Purpose	Usage
feature_get_stats	Progress overview	Start/end of session
feature_get_next	Get next feature	Start implementation
feature_mark_in_progress	Claim feature	After getting next
feature_mark_passing	Complete feature	After implementation
feature_skip	Defer feature	When blocked
feature_clear_in_progress	Reset status	When abandoning
feature_get_for_regression	Get test features	After changes
feature_create_bulk	Initialize features	Project setup

Full documentation: See D:\ClaudeTools\mcp-servers\feature-management\README.md

---

Typical Autonomous Coding Workflow

Phase 1: Project Initialization

# 1. Create app specification
/create-spec
# Follow prompts to define your application

# 2. Review and save APP_SPEC.md
# Edit as needed, commit to version control

# 3. Initialize feature list
# Use MCP tool to create features from spec
feature_create_bulk(features=[...])

Phase 2: Development Loop

# 1. Check progress
feature_get_stats()
# Output: 15/50 features (30%)

# 2. Get next feature
next_feature = feature_get_next()
# Feature #16: "User authentication endpoint"

# 3. Mark in-progress
feature_mark_in_progress(feature_id=16)

# 4. Implement feature
# ... write code, run tests ...

# 5. Create checkpoint
/checkpoint
# Commits changes and saves context

# 6. Mark complete
feature_mark_passing(feature_id=16)

# 7. Regression test
regression = feature_get_for_regression(limit=5)
# Test 5 random passing features

Phase 3: Handling Blockers

# Get next feature
next = feature_get_next()
# Feature #20: "OAuth integration"

# Realize it depends on incomplete feature #25
feature_skip(feature_id=20)
# Moved to end of queue

# Continue with next available
next = feature_get_next()
# Feature #21: "Email validation"

---

Integration with ClaudeTools API

The AutoCoder resources integrate seamlessly with the existing ClaudeTools infrastructure:

1. Context Recall Integration

Save feature completion context:

POST /api/conversation-contexts
{
  "project_id": "uuid",
  "context_type": "feature_completion",
  "title": "Completed Feature #16: User authentication",
  "dense_summary": "Implemented JWT-based auth with bcrypt password hashing...",
  "relevance_score": 8.0,
  "tags": ["authentication", "feature-16", "jwt", "bcrypt"]
}

2. Decision Logging

Log architectural decisions:

POST /api/decision-logs
{
  "project_id": "uuid",
  "decision_type": "technical",
  "decision_text": "Use JWT for stateless authentication",
  "rationale": "Scalability, no server-side session storage needed",
  "alternatives_considered": ["Session cookies", "OAuth only"],
  "impact": "high",
  "tags": ["authentication", "architecture"]
}

3. Session Tracking

Track feature development sessions:

POST /api/sessions
{
  "project_id": "uuid",
  "machine_id": "machine-uuid",
  "started_at": "2026-01-17T10:00:00Z",
  "metadata": {"feature_id": 16, "feature_name": "User authentication"}
}

4. Problem Solutions

Save implementation solutions:

POST /api/context-snippets
{
  "snippet_type": "solution",
  "title": "JWT token validation middleware",
  "content": "async def validate_token(request): ...",
  "language": "python",
  "tags": ["authentication", "jwt", "middleware"],
  "relevance_score": 7.5
}

---

Configuration Files

Claude Desktop Config

Full example configuration:

{
  "mcpServers": {
    "features": {
      "command": "D:\\ClaudeTools\\venv\\Scripts\\python.exe",
      "args": ["D:\\ClaudeTools\\mcp-servers\\feature-management\\feature_mcp.py"],
      "env": {
        "PROJECT_DIR": "D:\\ClaudeTools\\projects\\my-web-app"
      }
    }
  },
  "globalShortcut": "Ctrl+Space"
}

Environment Variables

For MCP server:

• PROJECT_DIR - Required. Where features.db will be stored.

For ClaudeTools API:

• DATABASE_URL - Connection string to ClaudeTools database
• JWT_SECRET_KEY - For API authentication
• ENCRYPTION_KEY - For credential encryption

---

Testing the Integration

1. Test Commands

# Test create-spec
/create-spec
# Should display specification creation interface

# Test checkpoint
/checkpoint
# Should create git commit and save context

2. Test Skills

# Test frontend-design
/frontend-design
# Should activate frontend design mode

3. Test MCP Server

# In Claude Code with MCP server running

# Test stats
feature_get_stats()
# Should return progress statistics

# Test get next
feature_get_next()
# Should return next feature or error if empty

4. Test Templates

Templates are used internally by commands, but you can view them:

# View templates
cat D:\ClaudeTools\.claude\templates\app_spec.template.txt
cat D:\ClaudeTools\.claude\templates\coding_prompt.template.md

---

Troubleshooting

Commands Not Available

Problem: /create-spec or /checkpoint not showing in command list

Solution:

1. Verify files exist in .claude/commands/
2. Restart Claude Code
3. Check file permissions (should be readable)

Skill Not Loading

Problem: /frontend-design skill not available

Solution:

1. Verify SKILL.md exists in .claude/skills/frontend-design/
2. Check SKILL.md syntax (must be valid markdown)
3. Restart Claude Code

MCP Server Not Connecting

Problem: Feature tools not available in Claude Code

Solution:

1. Verify Claude Desktop config is valid JSON
2. Check PROJECT_DIR environment variable is set
3. Ensure Python can be found (use full path if needed)
4. Check MCP server logs (see Claude Desktop logs)
5. Restart Claude Desktop (not just the window)

Windows log location:

%APPDATA%\Claude\logs\

macOS log location:

~/Library/Logs/Claude/

Database Issues

Problem: MCP server can't create/access database

Solution:

1. Verify PROJECT_DIR exists and is writable
2. Check file permissions on PROJECT_DIR
3. Manually create directory if needed:

   mkdir -p "D:\ClaudeTools\projects\your-project"
   

---

Best Practices

1. Spec-Driven Development

Always start with a specification:

1. Use /create-spec to document requirements
2. Review and refine the spec before coding
3. Use spec as input for feature_create_bulk
4. Keep spec updated as requirements evolve

2. Checkpoint Frequently

Create checkpoints at natural boundaries:

• After completing each feature
• Before starting risky refactoring
• At end of coding sessions
• When switching between tasks

3. Feature Management

Maintain clean feature state:

• Always mark features in-progress when starting
• Mark passing only when fully tested
• Skip features when blocked (don't leave them in-progress)
• Use regression testing after significant changes

4. Context Recall

Integrate with ClaudeTools context system:

• Save feature completions to conversation_contexts
• Log architectural decisions to decision_logs
• Store reusable solutions to context_snippets
• Tag everything for easy retrieval

---

Migration Notes

From AutoCoder to ClaudeTools

What changed:

• Commands moved from AutoCoder .claude/ to ClaudeTools .claude/
• MCP server moved to dedicated mcp-servers/ directory
• Templates now in .claude/templates/ (new directory)
• Skills now in .claude/skills/ (new directory)

What stayed the same:

• Command syntax and functionality
• MCP server API (same tools, same parameters)
• Template structure
• Skill format

Backwards Compatibility

These AutoCoder resources are compatible with:

• Claude Code (current version)
• Claude Desktop MCP protocol
• ClaudeTools API (Phase 6, context recall)

Not compatible with:

• Older AutoCoder versions (pre-MCP)
• Legacy JSON-based feature tracking (auto-migrated)

---

Next Steps

Recommended Actions

1. Try the commands:

   • Run /create-spec on a test project
   • Create a checkpoint with /checkpoint

2. Set up MCP server:

   • Configure Claude Desktop
   • Test feature management tools
   • Create initial feature list

3. Integrate with ClaudeTools:

   • Connect feature completions to context recall
   • Log decisions to decision_logs
   • Track sessions with metadata

4. Customize templates:

   • Review templates in .claude/templates/
   • Adjust to match your coding style
   • Add project-specific requirements

---

Resources

Documentation

• MCP Server: mcp-servers/feature-management/README.md
• Config Example: mcp-servers/feature-management/config.example.json
• ClaudeTools Docs: .claude/CLAUDE.md
• Context Recall: .claude/CONTEXT_RECALL_QUICK_START.md

Source Files

• Commands: .claude/commands/
• Skills: .claude/skills/
• Templates: .claude/templates/
• MCP Servers: mcp-servers/

AutoCoder Project

• Original Source: /c/Users/MikeSwanson/claude-projects/Autocode-remix/Autocode-fork/autocoder-master
• Conversation History: imported-conversations/auto-claude-variants/autocode-remix-fork/

---

Version History

Date	Version	Changes
2026-01-17	1.0	Initial integration from AutoCoder

---

Last Updated: 2026-01-17 Integration Status: Complete Tested: Windows 11, ClaudeTools v0.95