amplihack¶

Agentic coding framework that uses specialized AI agents to accelerate software development through intelligent automation and collaborative problem-solving.

What is amplihack?¶

amplihack is a development tool built on Claude Code that leverages multiple specialized AI agents working together to handle complex software development tasks. It combines ruthless simplicity with powerful capabilities to make AI-assisted development more effective and maintainable.

Quick Navigation¶

New to amplihack? Start here:

• Get Started - Installation and first steps
• Core Concepts - Philosophy and principles
• First Docs Site Tutorial - Create your first documentation site

Looking for something specific?

• Commands & Operations - Execute complex tasks
• Workflows - Structured development processes
• Agents & Tools - Specialized AI capabilities
• Troubleshooting - Fix common issues

🚀 Get Started¶

Everything you need to install and configure amplihack.

Installation¶

• Prerequisites - System requirements and dependencies
• Interactive Installation - Step-by-step setup wizard
• Quick Start - Basic usage and first commands

Configuration¶

• Profile Management - Multiple environment configurations
• Proxy Configuration - Network proxy setup
• Hook Configuration - Customize framework behavior

Deployment¶

• UVX Deployment - Deploy with uvx
• UVX Data Models - Understanding uvx data structures
• Azure Integration - Deploy to Azure cloud

💡 Core Concepts¶

Understand the philosophy and architecture behind amplihack.

Philosophy & Principles¶

• Development Philosophy - Ruthless simplicity and modular design
• This Is The Way - Best practices and patterns
• Workspace Pattern - Organize your development environment
• Trust & Anti-Sycophancy - Honest agent behavior

Architecture¶

• Project Overview - System architecture
• Development Patterns - Proven implementation patterns
• Blarify Architecture - Understanding the Blarify integration
• Documentation Knowledge Graph - How docs connect

Key Features¶

• Modular Design - Self-contained modules (bricks & studs)
• Zero-BS Implementation - No stubs or placeholders
• Specialized AI Agents - Purpose-built for each task
• Structured Workflows - Proven methodologies

📋 Workflows¶

Proven methodologies for consistent, high-quality results.

Core Workflows¶

• Default Workflow - Standard multi-step development process
• Investigation Workflow - Deep codebase analysis and understanding
• Document-Driven Development (DDD) - Documentation-first approach for large features

DDD Deep Dive¶

Document-Driven Development is a systematic methodology where documentation comes first and acts as the specification.

• Core Concepts
• Overview - What is DDD and when to use it
• Core Concepts - File crawling, context poisoning, retcon writing
• File Crawling - Systematic file processing
• Context Poisoning - Preventing inconsistencies

• Retcon Writing - Present-tense documentation

• Implementation Phases

• Phase 0: Planning - Define scope and objectives
• Phase 1: Documentation - Write the spec
• Phase 2: Approval - Review and validate
• Phase 3: Code Planning - Implementation strategy
• Phase 4: Implementation - Build it
• Phase 5: Testing - Verify behavior

• Phase 6: Cleanup - Final touches

• Reference

• Reference Materials - Practical resources
• Checklists - Phase verification
• Tips for Success - Best practices
• Common Pitfalls - What to avoid
• FAQ - Common questions

Advanced Workflows¶

• N-Version Programming - Multiple solutions for critical code
• Multi-Agent Debate - Structured decision-making
• Cascade Workflow - Graceful degradation patterns
• Workflow Enforcement - Ensure process compliance

🤖 Agents & Tools¶

Specialized AI agents and tools for every development task.

Core Agents¶

• Agents Overview - Complete agent catalog
• Architect - System design and specifications
• Builder - Code implementation from specs
• Reviewer - Quality assurance and compliance
• Tester - Test generation and validation

Specialized Agents¶

• API Designer - Contract definitions
• Security Agent - Vulnerability assessment
• Database Agent - Schema and query optimization
• Integration Agent - External service connections
• Cleanup Agent - Code simplification

Goal-Seeking Agents¶

Autonomous agents that iterate toward objectives without stopping.

• Goal Agent Generator Guide - Create custom goal-seeking agents
• Goal Agent Generator Presentation - Concept overview
• Goal Agent Generator Design - Architecture and patterns
• Goal Agent Requirements - Specifications
• Implementation Summary - Current status

Key Feature: Goal-seeking agents work autonomously toward a defined objective, iterating and adapting without requiring user intervention at each step. Perfect for complex, open-ended tasks.

Workflow Agents¶

• Ambiguity Handler - Clarify unclear requirements
• Optimizer - Performance improvements
• Pattern Recognition - Identify reusable solutions

Claude Code Skills¶

Modular, on-demand capabilities that extend amplihack:

• Skills Catalog - Complete skills catalog
• Documentation Writing - Eight Rules compliance
• Mermaid Diagrams - Visual documentation
• Test Gap Analyzer - Find untested code
• Code Smell Detector - Identify anti-patterns

Scenario Tools¶

Production-ready executable tools following the Progressive Maturity Model:

• Scenario Tools Overview - Progressive maturity model
• Create Your Own Tools - Build custom tools
• Agent Bundle Generator - Package agents for distribution

Available Tools¶

• check-broken-links - Automated link checker for documentation sites and markdown files
• Check GitHub Pages sites or local documentation
• Catch broken internal links and dead external URLs
• Integrates with Makefile: make check-broken-links TARGET=<url-or-path>
• Returns exit codes for CI integration

⚡️ Commands & Operations¶

Execute complex tasks with simple slash commands.

Command Reference¶

• Command Selection Guide - Choose the right command for your task

Core Commands¶

• /ultrathink - Main orchestration command (reads workflow, orchestrates agents)
• /analyze - Comprehensive code review for philosophy compliance
• /improve - Capture learnings and self-improvement
• /fix - Intelligent fix workflow for common error patterns

Document-Driven Development Commands¶

• /ddd:0-help - Get help and understand DDD
• /ddd:prime - Prime context with DDD overview
• /ddd:1-plan - Phase 0: Planning & Alignment
• /ddd:2-docs - Phase 1: Documentation Retcon
• /ddd:3-code-plan - Phase 3: Implementation Planning
• /ddd:4-code - Phase 4: Code Implementation
• /ddd:5-finish - Phase 5: Testing & Phase 6: Cleanup
• /ddd:status - Check current phase and progress

Advanced Commands¶

• /amplihack:n-version <task> - Generate N independent solutions for critical code
• /amplihack:debate <question> - Multi-agent structured debate for decisions
• /amplihack:cascade <task> - Fallback cascade for resilient operations
• /amplihack:customize - Manage user preferences and settings

Auto Mode¶

• Auto Mode Guide - Autonomous multi-turn execution
• Auto Mode Safety - Safety guardrails and best practices
• Passthrough Mode - Direct API access

🧠 Memory & Knowledge¶

Persistent memory systems and knowledge management.

Memory Systems¶

• Agent Memory Integration - How agents share and persist knowledge
• Agent Memory Quickstart - Get started with memory
• Agent Type Memory Sharing - Patterns for memory collaboration

Neo4j Memory System¶

Advanced graph-based memory for complex knowledge representation:

• Neo4j Memory Quick Reference - Fast answers
• Neo4j Phase 4 Implementation - Latest features
• Documentation Graph - Navigate documentation connections

Research & Deep Dives:

• Executive Summary
• Technical Research
• Design Patterns
• Integration Guides
• External Knowledge

Memory Testing¶

• A/B Test Summary - Performance comparisons
• A/B Test Quick Reference - Test results at a glance
• Effectiveness Test Design - How we measure success
• Final Cleanup Report - Memory system cleanup

External Knowledge¶

• External Knowledge Integration - Import external data sources
• Blarify Integration - Connect with Blarify knowledge base
• Blarify Quickstart - Get started with Blarify

🔧 Features & Integrations¶

Specific features and third-party integrations.

Power Steering¶

Intelligent guidance system that prevents common mistakes:

• Power Steering Overview - What is Power Steering
• Architecture - How it works
• Configuration - Setup and customization
• Troubleshooting - Fix infinite loop and other issues
• Migration Guide v0.9.1 - Upgrade guide
• Technical Reference - Developer reference
• Changelog v0.9.1 - Infinite loop fix release notes

Other Features¶

• Claude.md Preservation - Preserve custom instructions
• Neo4j Session Cleanup - Automatic resource management

Third-Party Integrations¶

• GitHub Copilot via LiteLLM - Use Copilot with amplihack
• OpenAI Responses API - OpenAI integration patterns
• MCP Evaluation - Model Context Protocol evaluation

⚙️ Configuration & Deployment¶

Advanced configuration, deployment patterns, and environment management.

Configuration¶

• Profile Management - Multiple environment configurations
• Proxy Configuration - Network proxy setup
• Hook Configuration - Customize framework behavior
• Shell Command Hook - Custom shell integrations

Deployment¶

• UVX Deployment Solutions - Production deployment with uvx
• UVX Data Models - Understanding uvx data structures
• Azure Integration - Deploy to Azure cloud
• Test Azure Proxy - Validate Azure proxy setup

Remote Sessions¶

• Remote Sessions Overview - Execute on remote machines
• Remote Session Architecture - How remote execution works
• Remote Session Security - Secure remote operations

🧪 Testing & Quality¶

Testing strategies, quality assurance, and validation patterns.

Testing¶

• Benchmarking - Performance measurement and comparison
• Test Gap Analyzer - Find untested code
• CS Validator - Code style validation
• Testing Strategies - Comprehensive testing guide

Code Review¶

• Code Review Guide - Review process and standards
• Memory Code Review - Example: Memory system review
• Workflow Completion - Checklist for finishing features

🔒 Security¶

Security guidelines, context preservation, and best practices.

Security Documentation¶

• Security Recommendations - Essential security practices
• Security Context Preservation - Maintain security through sessions
• Security Guides - Comprehensive security documentation

Safe Operations¶

• Auto Mode Safety - Autonomous operation guardrails
• Passthrough Mode - Direct API access patterns

🛠️ Troubleshooting & Discoveries¶

Fix common issues and learn from past solutions.

Troubleshooting¶

• Discoveries - Known issues and solutions (CHECK HERE FIRST!)
• Troubleshooting Guides - Common problems and fixes
• Tool Null Name Analysis - Debugging tool name issues
• Config Analysis Report - Configuration problem diagnosis

Documentation Guides¶

• Documentation Guidelines - Writing effective docs
• Documentation Structure Analysis - Current state of docs
• How to Generate GitHub Pages - Publish your docs

🔬 Research & Advanced Topics¶

Cutting-edge research, experimental features, and deep technical dives.

Research Projects¶

• Neo4j Memory System Research - Complete research archive
• Executive Summary
• Technical Research
• Design Patterns
• Integration Guides
• External Knowledge

Advanced Topics¶

• Agent Type Memory Sharing Patterns - Advanced memory patterns
• Documentation Knowledge Graph - Graph-based doc navigation
• Workspace Pattern - Advanced workspace organization

📚 Reference & Resources¶

Quick references, guides, and additional resources.

Quick References¶

• Command Selection Guide - Choose the right command
• Doc Graph Quick Reference - Navigate documentation
• Neo4j Quick Reference - Memory system commands
• A/B Test Quick Reference - Test results

Developing amplihack¶

• Developing amplihack - Contribute to the framework
• Create Your Own Tools - Build custom tools
• Workflow to Skills Migration - Migration guide

GitHub & Community¶

• GitHub Repository - Source code
• Issue Tracker - Report bugs or request features
• GitHub Pages - Online documentation

Philosophy in Action¶

amplihack follows three core principles:

1. Ruthless Simplicity: Start with the simplest solution that works. Add complexity only when justified.

2. Modular Design: Build self-contained modules (bricks) with clear public contracts (studs) that others can connect to.

3. Zero-BS Implementation: No stubs, no placeholders, no dead code. Every function must work or not exist.

Example Workflow¶

# Start with a feature request
/ultrathink "Add user authentication to the API"

# UltraThink will:
# 1. Read the default workflow
# 2. Orchestrate multiple agents (architect, security, api-designer, database, builder, tester)
# 3. Follow all workflow steps systematically
# 4. Ensure quality and philosophy compliance
# 5. Generate tests and documentation

Use Cases¶

amplihack excels at:

• Feature Development: Orchestrate multiple agents to design, implement, test, and document new features
• Code Review: Comprehensive analysis for philosophy compliance and best practices
• Refactoring: Systematic cleanup and improvement of existing code
• Investigation: Deep understanding of complex codebases and architectures
• Integration: Connect external services with proper error handling and testing
• Security: Vulnerability assessment and secure implementation patterns

Need Help?¶

• Start here: Prerequisites → Interactive Installation → Quick Start
• Common issues: Check Discoveries first
• Questions: See DDD FAQ
• Report issues: GitHub Issues

Ready to get started? Head to Prerequisites to set up amplihack in your development environment.