---

🌟 Overview

Context Forge is a powerful CLI tool that bridges the gap between project requirements and AI-assisted development. By implementing Andre Karpathy's context engineering principles, it generates comprehensive documentation structures that enable AI IDEs to understand and build your project efficiently—without hallucinations or context confusion.

$3

🌐 Universal AI IDE Support - Works with ALL major AI coding assistants
⚡ Zero Configuration - Intelligent defaults for each IDE
🎯 One Command - Generate configs for multiple IDEs simultaneously
🔄 Format Conversion - Switch between IDEs without starting over
🔗 Claude Hooks Integration - Seamless context preservation during compaction
📦 No Lock-in - Your project, your choice of AI assistant

$3

Claude Code Full PRP support	Cursor IDE PRP + MDC format	Windsurf PRP + Cascade AI
Cline PRP + Context mgmt	Roo Code Hierarchical rules	Gemini PRP + CLI & Code Assist	GitHub Copilot Custom instructions

> Coming Soon: Amazon CodeWhisperer, Tabnine, and more!

$3

Need help understanding how each IDE uses its configuration? Check out our detailed guides:

- 🤖 Claude Code Guide - Full PRP support, validation system, tech-stack templates
- 🔵 Cursor IDE Guide - PRP support, MDC format, hierarchical rules
- 🟩 Windsurf Guide - PRP support, Cascade AI integration, workflows
- 🟢 Cline Guide - PRP support, context management, code patterns, advanced commands
- 🟣 Roo Code Guide - Workspace rules, YAML configuration, team settings
- 🟠 Gemini Guide - PRP support, hierarchical context, CLI commands, Code Assist integration
- ⚫ GitHub Copilot Guide - Custom instructions, VS Code settings, language-specific rules

$3

📚 Complete Claude Features Guide - Master the new advanced features:

- ⚡ Slash Commands Reference - 20+ pre-built commands for rapid development
- 🤖 PRP Runner Guide - Automated PRP execution with validation gates
- 📝 Enhanced PRP Templates - Four specialized templates for different scenarios
- 🎯 Orchestration Workflow - How all components work together

🤖 AI-Powered PRP Generation (NEW in v3.2.8)

Transform your project development with intelligent, feature-specific Product Requirement Prompts (PRPs) powered by OpenAI and Anthropic Claude.

$3

Unlike template-based PRPs, AI-powered PRPs are dynamically generated for each specific feature in your project, containing:

- Feature-specific implementation strategies tailored to your tech stack
- Intelligent gotchas and best practices based on your architecture
- Custom validation approaches optimized for the feature type
- Relevant documentation links curated by AI
- Complexity assessments and dependency analysis

$3

``bash


1. Set up your AI provider (one-time setup)

`
🤖 Generating AI PRP for: User Authentication & Authorization...
✅ AI content generated for: User Authentication & Authorization
📝 Generated: PRPs/feature-auth-prp.md

🤖 Generating AI PRP for: Google Drive Cloud Streaming...
✅ AI content generated for: Google Drive Cloud Streaming
📝 Generated: PRPs/feature-google-drive-cloud-streaming-prp.md
`

$3

Traditional Template PRP:
`markdown


TODO: Add implementation details

AI-Powered PRP for Google Drive Integration:
`markdown


$3

Enable Dart Integration:
`bash
context-forge init


Select "Enable Dart task integration? Yes"

Generated Dart Integration Files:
- .claude/dart_progress.json - Task progress tracking
- .claude/task_mapping.json - File-to-task relationships
- .claude/task_comments.json - Automated task comments
- .claude/task_suggestions.json - AI-generated task suggestions

$3

`bash


Generate project with hooks

1. Automatic Triggers: AI pauses at predefined critical points
2. Manual Checkpoints: Use /checkpoint command anytime
3. Verification Request: AI presents what was done and what needs testing
4. Human Decision: Approve to continue or request fixes

$3

- /checkpoint [description] - Create manual checkpoint
- /should-checkpoint - AI asks if checkpoint is needed
- /milestone-gate [milestone] - Major milestone verification

$3

`
🛑 CHECKPOINT: Human Verification Required

Analytics Dashboard - I've completed database schema setup:

✅ What I've Accomplished:
- Created PostgreSQL schema with 5 tables
- Set up foreign key relationships
- Added indexes for query optimization

🧪 Please Test:
1. Run: npm run db:migrate
2. Check tables exist: psql -c "\dt"
3. Verify foreign keys: psql -c "\d+ users"

📋 Critical Verification Points:
- [ ] All tables created successfully
- [ ] Foreign keys properly linked
- [ ] No data loss from existing tables

Please respond:
- ✅ "Approved" - Continue to next task
- ❌ "Issues: [description]" - Fix before proceeding
`

$3

Checkpoints are configured during project initialization or can be added to existing projects:

`yaml


.context-forge/checkpoints.yaml

`bash
npm install -g context-forge
`

![npm](https://npmjs.org/package/context-forge)

🚀 Quick Start

$3

- Node.js 18+ and npm 7+
- Git (for version control)
- A code editor (VS Code recommended)

$3

`bash


Initialize a new project

Note: Context Forge is a CLI tool and should be installed globally. Do not install it as a project dependency with npm install context-forge as this will add unnecessary files to your project.

`bash


Initialize in current directory

`bash
$ context-forge init

? Project name: Analytics Dashboard
? Project type: fullstack
? Project description: Real-time analytics dashboard with data visualization
? How would you like to provide the PRD? Create new PRD
? Frontend framework: nextjs
? Backend framework: fastapi
? Database: postgresql
? Select features: authentication, dashboard, realtime-updates, data-export
? Project timeline: standard
? Team size: small
? Enable PRP generation? Yes
? Enable AI-powered PRP generation? Yes
? Enable validation system? Yes
? Enable Human-in-the-Loop checkpoints? Yes
? Enable Claude Code hooks? Yes

✅ Project initialized successfully!

Generated files:
- CLAUDE.md (Next.js 15 specific configuration)
- Docs/Implementation.md (4 development stages)
- Docs/project_structure.md
- PRPs/base.md (Implementation prompt with validation gates)
- .claude/commands/ (20+ slash commands)
- .claude/hooks/ (4 Claude Code hooks)
- .context-forge/config.json

Next steps:
1. cd analytics-dashboard
2. Set up AI keys (optional): context-forge ai-keys
3. Review CLAUDE.md for project rules
4. Use /prime-context to load project knowledge and activate architect mode
5. Start with Stage 1 in Docs/Implementation.md
`

$3

`bash
$ context-forge init --output user-service

? Project name: User Service
? Project type: api
? Project description: User management microservice with JWT auth
? Frontend framework: none
? Backend framework: express
? Database: mongodb
? Authentication method: jwt
? Enable Docker support? Yes
? Enable GitHub Actions? Yes

Generated structure:
user-service/
├── CLAUDE.md # Express.js specific rules
├── Docs/
├── PRPs/
├── Dockerfile
├── docker-compose.yml
└── .github/workflows/
`

$3

`bash
$ context-forge init --output nuxt-dashboard

? Project name: Analytics Dashboard
? Project type: fullstack
? Project description: Modern analytics dashboard with real-time data
? Frontend framework: nuxt4 # NEW: Nuxt 4 option
? Styling framework: tailwind
? State management: pinia
? Backend framework: fastapi
? Database: postgresql
? Authentication method: jwt
? Enable AI-powered PRP generation? Yes

Generated structure:
nuxt-dashboard/
├── CLAUDE.md # Nuxt 4 + Vue 3 specific rules
├── Docs/
├── PRPs/
│ ├── nuxt-dashboard-prp.md
│ └── feature-auth-prp.md # AI-enhanced for Nuxt 4
└── .claude/commands/ # 25+ slash commands

✨ Nuxt 4 Features Included:
- New app/ directory structure documented
- Vue 3 Composition API guidelines
- TypeScript integration with auto-imports
- SSR and data fetching best practices
- Pinia state management setup
`

$3

`bash


context-forge.json

`bash


1. Initialize with MVP timeline

`bash


1. Create detailed PRD first

`bash


1. Quick setup

NEW in v3.1.3+: The analyze command allows you to retrofit existing codebases with AI-optimized documentation. This is perfect for:

- Adding AI assistance to legacy projects
- Upgrading existing projects with modern context engineering
- Planning new features for established codebases
- Generating PRPs for upcoming development work

$3

1. Smart Analysis: Automatically detects your tech stack, project structure, and existing documentation
2. Interactive Setup: Asks about your future development plans
3. Non-Destructive: Never overwrites existing files (appends to CLAUDE.md with clear markers)
4. Feature PRPs: Generates individual PRP files for each planned feature
5. Comprehensive Summary: Creates a detailed retrofit summary with file tree visualization

$3

`bash


Run in your existing project directory

`
📁 Generated Files:
├── CLAUDE.md (UPDATED - appended retrofit section)
├── Docs/
│ ├── Implementation.md
│ ├── project_structure.md
│ ├── UI_UX_doc.md
│ └── Bug_tracking.md
└── PRPs/
├── user-authentication-prp.md
├── payment-integration-prp.md
└── api-v2-prp.md
`

The analyze command is intelligent enough to:

- Detect if you're using TypeScript, Python, or other languages
- Identify frameworks like React, Next.js, Express, FastAPI
- Find existing documentation to use as context
- Ask about your future plans to generate relevant PRPs

🔄 Technology Migration

NEW in v3.1.4: The migrate command helps you safely transition between technology stacks with comprehensive planning, risk analysis, and rollback strategies.

$3

Perfect for:
- Modernizing legacy applications (e.g., jQuery → React, Flask → FastAPI)
- Switching frameworks (e.g., Express → Next.js, Django → FastAPI)
- Adopting new technologies while maintaining production stability
- Planning complex migrations with shared resources (databases, auth systems)

$3

1. Analyzes Current Stack: Detects your existing technology and architecture
2. Assesses Complexity: Calculates migration risks and shared resource dependencies
3. Creates Phased Plan: Generates step-by-step migration with checkpoints
4. Provides Safety Net: Includes comprehensive rollback procedures
5. Monitors Progress: Tracks migration status with validation gates

$3

`bash


Interactive migration planning

`
🔄 Migration Analysis Complete!

Source: Flask + Jinja2 + SQLAlchemy
Target: Next.js + FastAPI + Prisma
Complexity: HIGH (Score: 78/100)
Recommended Strategy: parallel-run

📁 Generated Migration Files:
├── CLAUDE.md (Migration-aware configuration)
├── PRPs/
│ ├── migration-overview.md
│ ├── phase-1-infrastructure.md
│ ├── phase-2-api-migration.md
│ ├── phase-3-frontend-migration.md
│ └── rollback-procedures.md
└── .claude/
├── commands/migration/
│ ├── migration-status.md
│ ├── migration-checkpoint.md
│ └── migration-rollback.md
└── hooks/
├── MigrationCheckpoint.py
└── DataIntegrityCheck.py
`

$3

- Shared Resource Detection: Identifies databases, auth systems, and APIs used by both systems
- Risk Assessment: Analyzes potential breaking changes and data integrity risks
- Parallel-Run Support: Enables running old and new systems simultaneously
- Checkpoint System: Human verification at critical migration milestones
- Rollback Planning: One-command rollback to any checkpoint
- Progress Monitoring: Real-time migration status and health checks

$3

1. Big-Bang: Complete cutover (low complexity projects)
2. Incremental: Feature-by-feature migration (medium complexity)
3. Parallel-Run: Both systems active during transition (high complexity)

📚 Documentation

$3

Context Forge creates IDE-specific documentation structures:

#### Claude Code (Default)

`
project-folder/
├── CLAUDE.md # Main context file with tech-stack specific rules
├── Docs/
│ ├── Implementation.md # Staged development plan
│ ├── project_structure.md # Folder organization
│ ├── UI_UX_doc.md # Design specifications
│ └── Bug_tracking.md # Bug tracking template
├── PRPs/ # Product Requirement Prompts (if enabled)
│ ├── {project}-prp.md # Base implementation PRP
│ ├── {project}-planning.md # Architecture planning (if enterprise/team)
│ └── {feature}-prp.md # Feature-specific PRPs (if retrofit)
├── .claude/ # Claude Code specific configuration
│ ├── commands/ # Slash commands (20+ commands)
│ │ ├── PRPs/ # PRP management commands
│ │ ├── development/ # Development workflow commands
│ │ ├── checkpoints/ # Human-in-the-loop commands
│ │ └── migration/ # Migration commands (if applicable)
│ └── hooks/ # Claude Code hooks (if enabled)
│ ├── PreCompact.py # Context preservation hook
│ ├── ContextRotation.py # Smart file switching
│ ├── PreSubmit.py # Quality gates
│ ├── PRPTracking.py # Progress monitoring
│ ├── DartProgressUpdater.py # Dart task progress tracking
│ ├── AutoTaskCommenter.py # Automated task documentation
│ └── TaskCodeMapper.py # File-to-task mapping
└── ai_docs/ # AI documentation curation (if enabled)
└── README.md # Documentation guide
`

#### Cursor IDE

`
project-folder/
├── .cursorrules # Main Cursor rules file
└── .cursor/
└── rules/
├── global.md # Global development rules
├── project.md # Project-specific rules
├── prp-overview.mdc # PRP implementation overview
├── prp-stage-1.mdc # Foundation setup tasks
├── prp-stage-2.mdc # Core feature implementation
├── prp-stage-3.mdc # Advanced features & polish
└── prp-validation.mdc # Validation gates & checks
`

#### Cline

`
project-folder/
└── .clinerules/ # Configuration directory
├── README.md # Main configuration
├── context.md # Project context
├── rules.md # Development rules
├── patterns.md # Code patterns
├── prp-overview.md # PRP implementation overview
├── prp-stage-1.md # Foundation setup tasks
├── prp-stage-2.md # Core feature implementation
├── prp-stage-3.md # Advanced features & polish
└── prp-validation.md # Validation gates & checks
`

#### Gemini

`
project-folder/
├── GEMINI.md # Main Gemini configuration
└── .gemini/
├── context/
│ ├── project.md # Project context
│ ├── architecture.md # Architecture docs
│ └── guidelines.md # Development guidelines
├── prp/ # PRP files (if features defined)
│ ├── overview.md # PRP implementation overview
│ ├── stage-1-foundation.md
│ ├── stage-2-core.md
│ ├── stage-3-advanced.md
│ └── validation.md
└── config.yaml # Gemini config with PRP settings
`

$3

#### CLAUDE.md

The main context file that Claude Code reads first. It contains:

- Project overview and tech stack
- Development philosophy (KISS, YAGNI)
- Code structure rules and limits
- Tech-stack specific guidelines
- Testing requirements
- Pre-commit checklist

#### Docs/Implementation.md

Your roadmap with staged development:

- Stage 1: Foundation (1-2 weeks) - Setup, configuration, base structure
- Stage 2: Core Features (2-3 weeks) - Must-have functionality
- Stage 3: Advanced Features (2-3 weeks) - Should-have features
- Stage 4: Polish & Optimization (1-2 weeks) - Testing, performance

Each stage contains:

- Dependencies and prerequisites
- Detailed task checklist
- Validation requirements
- Expected deliverables

#### PRPs (Product Requirement Prompts)

Advanced prompts for complex implementations:

- base.md - Implementation blueprint with pseudocode
- planning.md - Architecture diagrams and decisions
- spec.md - Technical specifications
- validation-gate.md - Quality checkpoints

$3

When you run context-forge init, you'll be guided through:

1. Project Information - Name, type, and description
2. PRD Input - Provide or create product requirements
3. Tech Stack Selection - Choose frontend, backend, and database
4. Feature Selection - Pick core features for your MVP
5. Configuration - Timeline, team size, and deployment
6. Advanced Options - PRP, validation, AI docs

$3

#### Frontend Frameworks

- Next.js 15 - App Router, Server Components, React 19
- Nuxt 4 - NEW! Vue-based full-stack with enhanced TypeScript support
- React - SPA with TypeScript and modern patterns
- Vue.js 3 - Composition API and TypeScript
- Angular - Standalone components, RxJS
- Vanilla JavaScript - No framework approach

#### Backend Frameworks

- FastAPI (Python) - Async, Pydantic v2, type hints
- Express.js (Node.js) - TypeScript, middleware patterns
- Django (Python) - MVT, ORM, admin interface
- Spring Boot (Java) - REST APIs, dependency injection
- Ruby on Rails - Convention over configuration

#### Databases

- PostgreSQL, MySQL, MongoDB, SQLite, Redis

$3

Context Forge includes a powerful validation system that ensures code quality:

`bash


Run all critical validations

| Level | Description | Critical | Commands |
| ------------ | -------------------------- | -------- | ------------------------------- |
| syntax | Type checking and linting | ✅ Yes | tsc, eslint, mypy, etc. |
| tests | Unit and integration tests | ✅ Yes | jest, pytest, rspec, etc. |
| coverage | Code coverage analysis | ❌ No | With coverage reporters |
| build | Production build | ✅ Yes | Framework-specific build |
| security | Vulnerability scanning | ❌ No | npm audit, safety, etc. |

#### Example Validation Report

`
📊 Validation Report - Analytics Dashboard
==================================================
✅ Status: PASSED

Total: 5 | Passed: 5 | Failed: 0

✅ syntax:tsc --noEmit (342ms)
✅ syntax:eslint src --ext .ts,.tsx (567ms)
✅ tests:jest --coverage (4521ms)
✅ build:next build (8234ms)
✅ security:npm audit (1023ms)

Full report saved to: .validation-reports/latest-report.md
`

$3

Skip interactive prompts with a configuration file:

`json
{
"projectName": "My App",
"projectType": "fullstack",
"description": "A collaborative platform",
"techStack": {
"frontend": "nextjs",
"backend": "fastapi",
"database": "postgresql",
"auth": "jwt"
},
"features": [
{
"id": "auth",
"name": "Authentication",
"priority": "must-have"
}
],
"extras": {
"prp": true,
"validation": true,
"docker": true
}
}
`

Use with: context-forge init --config context-forge.json

🔄 Complete Workflow

$3

`bash


Run the init command

`bash


1. Start with CLAUDE.md

`bash


After completing each stage

Create your own templates in ~/.context-forge/templates/:

`bash


Custom tech stack template

Add pre/post hooks in .context-forge/hooks/:

`bash


pre-init.sh - Run before initialization

`yaml


.github/workflows/validate.yml

jobs:
validate:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-node@v3
- run: npm install -g context-forge
- run: context-forge validate --all
`

🏗️ Development

`bash


Clone the repository

`
context-forge/
├── src/
│ ├── cli/ # CLI entry point and commands
│ ├── commands/ # Command implementations
│ ├── generators/ # Document generators
│ ├── templates/ # Handlebars templates
│ ├── data/ # Tech stack configurations
│ └── types/ # TypeScript definitions
├── templates/ # Document templates
└── tests/ # Test files
``

🙏 Credits

$3

This project was inspired by and built upon the work of amazing developers:

- Rasmus Widing (Wirasm) - For the incredible PRPs-agentic-eng project that provided the foundation for our PRP (Product Requirement Prompt) system. The PRP methodology and validation loops are directly inspired by Rasmus's groundbreaking work.
- AILABS (@AILABS-393) - For the excellent educational content and YouTube tutorials on AI-assisted development, prompt engineering, and Claude Code workflows
- AI Labs Discord Community - For feedback, ideas, and support
- Dynamous.ai Community - For pioneering work in AI-assisted development and collaborative innovation

$3

- Andre Karpathy - Context engineering principles
- Claude Code by Anthropic - The AI assistant this tool is designed for
- Commander.js - CLI framework
- Inquirer.js - Interactive prompts
- Handlebars - Template engine

🤝 Contributing

Contributions are welcome! Please read our Contributing Guide for details on our code of conduct and the process for submitting pull requests.

$3

- 🐛 Report bugs and issues
- 💡 Suggest new features
- 📝 Improve documentation
- 🔧 Add new tech stack templates
- 🌐 Translate documentation
- ⭐ Star the project!

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

🔗 Links

- Repository: github.com/webdevtodayjason/context-forge
- npm Package: npmjs.com/package/context-forge
- Issues: GitHub Issues
- Discussions: GitHub Discussions

---

---