Install from VS Code Marketplace with one click. Automatic MCP server integration. No manual configuration required
Key features
01Install from VS Code Marketplace with one click
02Automatic MCP server integration
03No manual configuration required
04VS Code extension works with any language via Debug Adapter Protocol
05Standalone MCP server works with Node.js/JavaScript via Chrome DevTools Protocol
06AI-powered debugging assistance in your editor
๐ AI Capability Extension Suite
What if AI agents could actually see, debug, and control your development environment?
We've built the most comprehensive suite of MCP servers that give AI agents superpowers they've never had before. This isn't just another tool collectionโit's a paradigm shift that transforms AI assistants from code generators into intelligent development partners with runtime visibility, system control, and physical world access.
๐ Note: All packages have been split into individual Git submodules with their own repositories for better maintainability and independent versioning. Each package now has its own dedicated repository under the Digital-Defiance organization.
Our flagship MCP ACS Debugger is now available as a native VS Code extension, bringing professional-grade debugging capabilities directly to your editor with zero configuration required.
Why developers love it:
โ One-click installation from VS Code Marketplace
โ GitHub Copilot integration for AI-powered debugging
โ 25+ debugging tools accessible to AI agents
โ Zero configuration - works immediately after install
โ Enterprise-grade quality with 94.53% test coverage
The Problem: AI agents were blind to runtime behavior. They could read your code and suggest fixes, but couldn't see what was actually happening when your code ran. Debugging remained a frustratingly manual process.
The Solution: AI agents can now debug like senior developersโsetting breakpoints, inspecting variables, profiling performance, and detecting infinite loops in real-time. Available as both a standalone MCP server and a native VS Code extension with GitHub Copilot integration.
๐จ VS Code Extension Features
Zero-Configuration Setup:
Install from VS Code Marketplace with one click
Automatic MCP server integration
No manual configuration required
VS Code extension works with any language via Debug Adapter Protocol
Standalone MCP server works with Node.js/JavaScript via Chrome DevTools Protocol
GitHub Copilot Integration:
AI-powered debugging assistance in your editor
Copilot can access debugging context and tools
Natural language debugging commands
Intelligent breakpoint suggestions
Native IDE Integration:
Language Server Protocol (LSP) for code intelligence
Debug Adapter Protocol (DAP) for seamless debugging
Hover providers for variable inspection
Code lens for breakpoint management
Integrated debugging UI
Professional Debugging Workflow:
Set breakpoints with right-click context menu
Step through code with keyboard shortcuts
Inspect variables in hover tooltips
View call stack in debug panel
Profile performance without leaving editor
Language Support:
VS Code Extension: Multi-language support via Debug Adapter Protocol
JavaScript/TypeScript, Python, Java, C/C++, Go, Rust, PHP, Ruby, and more
Test Frameworks: Jest, Mocha, Vitest, pytest, JUnit, go test, cargo test
Frameworks: React, Vue, Angular, Django, Spring Boot, and more
Standalone MCP Server: Node.js/JavaScript only via Chrome DevTools Protocol
Full TypeScript support with source maps
Test Frameworks: Jest, Mocha, Vitest
Frameworks: Express, Nest.js, React (Node.js SSR), and more
๐ฅ Why This Changes Everything
For Developers:
"Debug this for me" becomes realityโAI investigates and fixes runtime issues
Instant performance insightsโAI identifies bottlenecks and memory leaks automatically
Intelligent test debuggingโAI debugs failing tests and suggests precise fixes
Proactive hang detectionโNever lose time to infinite loops again
For AI Agents:
Runtime visibilityโSee what's actually happening when code executes
Interactive debuggingโSet breakpoints, step through code, inspect state
Performance analysisโProfile CPU, memory, and execution timelines
Intelligent problem solvingโCombine static analysis with runtime behavior
๐ ๏ธ 25+ Professional Debugging Tools
Core Debugging (17 tools):
๐ Session management (start, stop with clean shutdown)
๐ฏ Breakpoint operations (set, remove, toggle, list with conditional logic)
โถ๏ธ Execution control (continue, step over/into/out, pause)
You: "My Jest test is failing but I can't figure out why"
AI: *Sets breakpoints in test, inspects variables, identifies exact divergence*
AI: "Line 42: API returns string but test expects number. Here's the fix..."
"AI, find the performance bottleneck"
You: "This function is slow but I don't know why"
AI: *Starts CPU profiling, analyzes flame graphs, identifies hot paths*
AI: "Bottleneck in nested loop on line 156. Here's 10x faster version..."
"AI, why is my app hanging?"
You: "My Node.js app freezes randomly"
AI: *Detects infinite loop, captures call stack, identifies root cause*
AI: "Infinite loop in processQueue() - exit condition never true because..."
"AI, debug this Node.js issue"
You: "My Express server crashes on startup"
AI: *Sets breakpoints, inspects variables, traces execution*
AI: "Missing environment variable 'PORT' on line 23. Server tries to bind to undefined port..."
๐ Get Started
Option 1: VS Code Extension (Recommended for VS Code users)
# Install from VS Code Marketplace
# Search for "MCP ACS Debugger" or visit:
# https://marketplace.visualstudio.com/items?itemName=digitaldefiance.ts-mcp-debugger
# Or install via command line
code --install-extension digitaldefiance.ts-mcp-debugger
โ Native VS Code debugging - Seamless IDE integration
โ Language Server Protocol - Smart code intelligence
โ Debug Adapter Protocol - Full debugging capabilities
Option 2: Standalone MCP Server (For other AI agents)
# NPM (Recommended)
npm install -g @ai-capabilities-suite/mcp-debugger-server
# Docker
docker run digitaldefiance/mcp-debugger-server
# Configure your AI agent (Kiro, Amazon Q, etc.)
{
"servers": {
"debugger": {
"command": "mcp-debugger-server"
}
}
}
Option 3: From Source
# Clone and build
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
yarn install && yarn build
# Run debugger server
node packages/mcp-debugger-server/dist/src/index.js
โจ Now available on NPM, Docker Hub, and VS Code Marketplace!
The Problem: AI agents were blind to your actual user interface. They could read HTML/CSS and suggest improvements, but couldn't see what users actually experienceโbroken layouts, poor contrast, misaligned elements, or accessibility issues.
The Solution: AI agents now have visual superpowersโthey can see, analyze, and document your applications like a senior UX designer. From automated documentation generation to accessibility audits, AI can now work with what users actually see.
๐จ Key Features
Screenshot Capture:
Full screen capture with multiple format support (PNG, JPEG, WebP, BMP)
Window-specific capture by title or ID
Region capture with precise boundary control
Display management - list and target specific monitors
Quality control - adjustable compression and optimization
Privacy & Security:
PII masking with Tesseract OCR integration
Window exclusion - skip sensitive applications
Secure defaults - privacy-first configuration
Permission handling - proper system permission checks
Cross-Platform Support:
Linux: X11 and Wayland support
macOS: Native screenshot APIs
Windows: Windows API integration
Docker: Headless capture with Xvfb
๐ ๏ธ 5 Professional Screenshot Tools
screenshot_capture_full - Capture entire screen with format options (PNG, JPEG, WebP, BMP)
screenshot_capture_window - Capture specific application windows by title or ID
screenshot_capture_region - Capture rectangular screen regions with precise boundaries
screenshot_list_displays - List connected displays with resolutions and scaling
screenshot_list_windows - List visible windows with titles, positions, and dimensions
Privacy & Security Features:
PII Masking - Automatically detect and blur sensitive information (emails, phone numbers, credit cards)
Window Exclusion - Skip password managers and authentication dialogs
Secure Defaults - Privacy-first configuration out of the box
Permission Handling - Proper system permission checks and user consent
๐ Enterprise-Grade Quality
267 tests with 100% pass rate
Full MCP protocol compliance verified
E2E testing (25 tests) for protocol validation
Unit testing (242 tests) for comprehensive coverage
VSCode extension testing (80+ tests)
Cross-platform validation (Linux, macOS, Windows)
Graceful failure handling for headless environments
You: "Document the user onboarding flow"
AI: *Captures each step, analyzes UI elements*
AI: "Generated step-by-step guide with 8 annotated screenshots, user journey map, and accessibility notes..."
"AI, audit this design for accessibility"
You: "Check if this form meets WCAG standards"
AI: *Captures form, analyzes contrast and spacing*
AI: "Found 3 issues: Submit button has 2.1:1 contrast (needs 4.5:1), labels lack focus indicators, touch targets under 44px..."
"AI, help debug this responsive layout"
You: "Why does my navbar break on mobile?"
AI: *Captures multiple viewport sizes*
AI: "Navigation collapses at 768px but hamburger menu overlaps logo. Here's the CSS fix with before/after comparison..."
"AI, compare these two design options"
You: "Which landing page converts better?"
AI: *Captures both versions, analyzes visual hierarchy*
AI: "Version B has 34% better visual flowโCTA button more prominent, hero text clearer, social proof positioned optimally..."
"AI, create a bug report with visuals"
You: "The checkout form validation isn't working"
AI: *Captures error states and user flow*
AI: "Created detailed bug report with 5 screenshots showing error conditions, expected vs actual behavior, and reproduction steps..."
๐ฅ What This Changes
Before: AI worked blind, relying on code descriptions
โ "The layout looks broken" โ AI guesses what's wrong
โ "Create documentation" โ AI writes generic text without visuals
โ "Check accessibility" โ AI can only review code, not actual contrast
โ "Debug responsive design" โ AI can't see actual breakpoint behavior
After: AI sees and analyzes your actual user interface
โ Visual debugging - AI identifies exact pixel-level issues
โ Intelligent documentation - AI creates guides with real screenshots and annotations
โ Accessibility audits - AI measures actual contrast ratios and spacing
โ Responsive testing - AI captures and compares different screen sizes
โ Design analysis - AI evaluates visual hierarchy and user experience
โ Professional bug reports - AI creates detailed reports with visual evidence
The Problem: AI agents needed advanced file operations beyond basic read/write, but without proper security boundaries, this posed significant risksโpath traversal attacks, unauthorized access to system files, and exposure of sensitive credentials.
The Solution: AI agents now have enterprise-grade filesystem operations with 10 layers of security validation. From batch operations with atomic rollback to real-time directory watching, AI can now safely manage your workspace files.
๐ฅ Key Features
Advanced Operations:
Batch operations - Execute multiple file operations atomically with rollback support
Directory watching - Monitor filesystem changes in real-time with event filtering
File search & indexing - Fast full-text search with metadata filtering
You: "Create atomic backup of all .ts files to backup folder"
AI: *Uses batch operations with rollback*
AI: "Backed up 47 TypeScript files (2.3 MB) atomically. All operations succeeded, no rollback needed."
"AI, watch for changes and rebuild"
You: "Watch src directory and notify me of changes"
AI: *Starts directory watch with filters*
AI: "Watching src/ recursively. Detected 3 changes: file1.ts modified, file2.ts created, file3.ts deleted."
"AI, find all TODOs in the codebase"
You: "Search for TODO comments in TypeScript files"
AI: *Builds index and searches content*
AI: "Found 23 TODO comments across 12 files. Most common: 'TODO: Add error handling' (5 occurrences)."
"AI, verify file integrity"
You: "Compute SHA-256 checksum for release.zip"
AI: *Computes checksum*
AI: "SHA-256: a3f5b8c2... File integrity verified against expected checksum."
"AI, analyze disk usage"
You: "What's taking up space in node_modules?"
AI: *Analyzes disk usage*
AI: "node_modules: 487 MB. Largest: webpack (45 MB), typescript (38 MB), @types/* (92 MB total)."
โจ Now available on NPM, Docker Hub, and VS Code Marketplace!
The Problem: AI agents couldn't safely manage system processes. They needed to run commands, monitor resources, and manage services, but without proper security boundaries, this posed significant risksโcommand injection, resource exhaustion, and privilege escalation.
The Solution: AI agents now have enterprise-grade process management with 6 layers of security validation. From launching processes with resource limits to managing long-running services with auto-restart, AI can now safely orchestrate your development environment.
๐ฅ Key Features
Process Management:
Process launching with arguments and environment variables
Resource monitoring - Track CPU, memory, threads, and I/O in real-time
Output capture - Separate stdout and stderr streams
Process termination - Graceful (SIGTERM) and forced (SIGKILL) with timeout escalation
Interactive processes - Send stdin input and retrieve buffered output
Timeout management - Automatic termination after specified duration
Service Management:
Long-running services with auto-restart capabilities
Health checks - Periodic validation of service health
Restart policies - Configurable retry limits and backoff strategies
Service lifecycle - Start, stop, restart, and monitor services
Process Groups:
Group management - Organize related processes
Pipeline creation - Chain processes with stdout/stdin piping
Batch operations - Terminate entire groups at once
Security (Defense-in-Depth):
Executable allowlist - Only pre-approved executables can run
Comprehensive testing with unit, integration, and E2E tests
Security-first design with defense-in-depth validation
Production-ready with graceful error handling
Cross-platform support (Linux, macOS, Windows)
Docker deployment with secure defaults
๐ฏ Revolutionary Use Cases
"AI, run my build and monitor resources"
You: "Build the project and tell me if it uses too much memory"
AI: *Launches build with resource limits, monitors in real-time*
AI: "Build completed in 45s. Peak memory: 512MB (within limits). CPU averaged 65%."
"AI, start my development services"
You: "Start the API server and database with auto-restart"
AI: *Starts services with health checks and restart policies*
AI: "Started 2 services: api-server (PID 1234), postgres (PID 1235). Health checks enabled."
"AI, create a data processing pipeline"
You: "Process data.txt through grep, sort, and uniq"
AI: *Creates process group with pipeline*
AI: "Pipeline created: cat โ grep โ sort โ uniq. Processing 10,000 lines..."
"AI, debug this hanging process"
You: "My script is stuck, what's it doing?"
AI: *Gets process stats and output*
AI: "Process consuming 100% CPU in infinite loop. Last output: 'Processing item 5000'. Shall I terminate it?"
"AI, run tests with timeout"
You: "Run the test suite but kill it if it takes more than 5 minutes"
AI: *Launches tests with 5-minute timeout*
AI: "Tests completed in 3m 42s. All 247 tests passed. Peak memory: 384MB."
๐ Get Started
Docker (Recommended):
# Pull the image
docker pull digitaldefiance/mcp-process:latest
# Create configuration
cat > config/mcp-process-config.json << EOF
{
"allowedExecutables": ["node", "python3", "npm"],
"maxConcurrentProcesses": 10,
"enableAuditLog": true
}
EOF
# Run with docker-compose
docker-compose up -d
NPM:
# Install globally
npm install -g @ai-capabilities-suite/mcp-process
# Create config
mcp-process --create-config ./mcp-process-config.json
# Edit config to add allowed executables
# Then start server
mcp-process --config ./mcp-process-config.json
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ AI Agents & IDEs โ
โ โโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโ โ
โ โ VS Code โ โ Kiro โ โ Amazon Q โ โ
โ โ + Copilot โ โ โ โ โ โ
โ โโโโโโโโฌโโโโโโโโ โโโโโโโโฌโโโโโโโโ โโโโโโโโฌโโโโโโโโ โ
โ โ โ โ โ
โ โ LSP/DAP โ MCP Protocol โ MCP Protocol โ
โ โ โ โ โ
โโโโโโโโโโโผโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโ
โ โ โ
โ โโโโโโโโฌโโโโโโโโโโโโ
โ โ
โโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ AI Capability Extension Suite โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ MCP ACS Debugger โ โ
โ โ โข 25+ debugging tools โ โ
โ โ โข VS Code extension with LSP/DAP integration โ โ
โ โ โข Standalone MCP server for other agents โ โ
โ โ โข 94.53% test coverage, 1,059 tests โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ System Capabilities (In Development) โ โ
โ โ โข Screenshot โข Recording โข Filesystem โข Process โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ Chrome DevTools Protocol, System APIs
โ
โโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ Your Development Environment โ
โ โข Node.js processes with Inspector Protocol โ
โ โข File system and process management โ
โ โข Screen capture and recording โ
โ โข Full system access with security controls โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Integration Paths
1. VS Code Extension (Native Integration)
Language Server Protocol (LSP) for code intelligence
Debug Adapter Protocol (DAP) for debugging
GitHub Copilot integration for AI assistance
Zero configuration required
2. MCP Server (Universal Integration)
Model Context Protocol for AI agent communication
Works with Kiro, Amazon Q, Claude Desktop, and other MCP clients
Flexible deployment (NPM, Docker, binaries)
Configurable via JSON
๐ฎ Revolutionary Use Cases
๐ค "AI, debug and fix this issue"
You: "My app crashes when processing large files"
AI: *Starts debugger, sets breakpoints, profiles memory*
AI: "Memory leak in line 156. Buffer not released. Here's the fix..."
๐ธ "AI, document this feature"
You: "Create documentation for the new dashboard"
AI: *Captures screenshots, analyzes UI, generates docs*
AI: "Created comprehensive guide with 12 annotated screenshots..."
๐ฅ "AI, create a demo video"
You: "Show how the authentication flow works"
AI: *Records screen, adds annotations, exports video*
AI: "Generated 2-minute demo with voiceover script..."
๐ "AI, organize my project files"
You: "Restructure this codebase following best practices"
AI: *Analyzes structure, moves files, updates imports*
AI: "Reorganized 247 files into proper architecture..."
๐ฆ Package Structure
๐ Debugging Capabilities
mcp-debugger-core - Core debugging engine with Chrome DevTools Protocol integration
# Clone the repository
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
# Install dependencies
yarn install
# Build all packages
yarn build
# Run tests
yarn test
Quick Start: MCP ACS Debugger
# Build debugger packages
npx nx build mcp-debugger-core
npx nx build mcp-debugger-server
# Run debugger tests
npx nx test mcp-debugger-core
npx nx test mcp-debugger-server
# Start debugger server
node packages/mcp-debugger-server/dist/src/index.js
# Run all tests
yarn test
# Test specific package
npx nx test mcp-debugger-core
npx nx test mcp-debugger-server
npx nx test mcp-screenshot
# Test with coverage
npx nx test mcp-debugger-core --coverage
# Run tests in watch mode
npx nx test mcp-screenshot --watch
Lint Commands
# Lint all packages
yarn lint
# Lint specific package
npx nx lint mcp-debugger-core
We're building the foundation for AI-powered development workflows.
By giving AI agents professional-grade capabilities, we're creating a future where:
โ Bugs are investigated automatically while you focus on features
โ Documentation is generated from actual system behavior
โ Demos are created with a single command
โ Code is organized following best practices automatically
โ Junior developers have access to senior-level expertise
This isn't just a tool suiteโit's the future of software development.
๐ Quick Start Options
For VS Code Users (Recommended)
# Install from VS Code Marketplace
code --install-extension digitaldefiance.ts-mcp-debugger
# Or search "MCP ACS Debugger" in VS Code Extensions
For Other AI Agents (Kiro, Amazon Q, Claude)
# Install globally via NPM
npm install -g @ai-capabilities-suite/mcp-debugger-server
# Or use Docker
docker run -p 3000:3000 digitaldefiance/mcp-debugger-server
# Or download standalone binary from GitHub Releases
For Contributors & Developers
# Clone and build from source
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
yarn install && yarn build && yarn test
๐ Project Statistics
Total Packages: 10 (5 production, 5 in development)
Total Tests: 1,059 tests across all packages
Test Pass Rate: 99.81% (1,050 passed, 2 flaky, 7 skipped)
Code Coverage: 94.53% lines, 83.45% branches
Lines of Code: 15,000+ lines of production code
Documentation: 10,000+ lines of comprehensive documentation
Supported Platforms: Linux, macOS, Windows
Node.js Versions: 16, 18, 20, 22
TypeScript Versions: 4.x, 5.x
๐ Why Choose This Suite?
1. Production-Ready Quality
Enterprise-grade testing with 94.53% coverage
Property-based testing with 22 correctness properties
Load testing with 100+ concurrent sessions
Chaos testing for reliability validation
Security testing for vulnerability detection
2. Multiple Integration Options
Native VS Code extension with zero configuration
Standalone MCP server for universal AI agent support
Docker containers for easy deployment
Standalone binaries for no-install usage
3. Comprehensive Feature Set
25+ debugging tools (most comprehensive in MCP ecosystem)
Performance profiling (CPU, memory, timeline)
Advanced breakpoint types (logpoints, exception, hit count, function)
# Clone and build from source
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
yarn install && yarn build && yarn test
๐ Installation Statistics
๐ Individual Package Repositories
Core MCP Servers
mcp-debugger-core - Core debugging engine with Chrome DevTools Protocol
The Problem: Traditional AI-assisted development lacks structureโrequirements are vague, designs are inconsistent, and implementation happens without proper planning. AI agents generate code without understanding the full context or ensuring correctness.
The Solution: Akira brings professional software engineering methodology to AI-assisted development. Using the Easy Approach to Requirements Syntax (EARS) and INCOSE quality rules, Akira guides AI through a structured workflow: Requirements โ Design โ Tasks โ Execution. With Model Context Protocol (MCP) integration, specifications persist across chat sessions, ensuring consistency and enabling property-based testing.
๐จ Key Features
Structured Spec-Driven Workflow:
Requirements Phase - Generate EARS-compliant requirements with INCOSE validation
Design Phase - Create technical designs with correctness properties
Tasks Phase - Generate actionable implementation plans with proper hierarchy
Execution Phase - Execute tasks with full context from requirements and design
Advanced Requirements Engineering:
EARS Compliance - All requirements follow one of six EARS patterns
INCOSE Quality Rules - Automatic validation against semantic quality standards
Glossary Management - Automatic extraction and definition of technical terms
User Story Structure - Consistent format with 2-5 acceptance criteria per requirement
Property-Based Testing Integration:
Correctness Properties - Generate testable properties from acceptance criteria
Universal Quantification - Properties formatted with explicit "For any" statements
Round-Trip Properties - Automatic detection for parsing/serialization requirements
Test Library Integration - Support for fast-check and other PBT libraries
Model Context Protocol (MCP) Integration:
Persistent Context - Spec documents remain accessible across chat sessions
Structured Tools - Programmatic access to spec operations via MCP tools
State Management - Track workflow progress and task completion
File Operations - Read, write, and update spec documents through MCP
๐ ๏ธ Workflow Phases
Requirements - Generate user stories with EARS patterns and INCOSE validation
Design - Create technical design with correctness properties for PBT
Tasks - Generate actionable implementation plan with 2-level hierarchy
Execution - Execute tasks with full context loading and status tracking
๐ฏ Revolutionary Use Cases
"AI, create a spec for user authentication"
You: "@spec create user-authentication"
AI: *Generates EARS-compliant requirements*
AI: "Created spec with 8 requirements (5 ubiquitous, 2 event-driven, 1 state-driven).
All requirements validated against INCOSE rules. Ready for design phase."
"AI, generate correctness properties"
You: "@spec approve requirements user-auth"
AI: *Moves to design phase, extracts properties*
AI: "Generated 12 correctness properties:
- For any valid credentials, login succeeds
- For any expired token, re-authentication required
- For any user, password hash is irreversible
Ready for implementation."
"AI, execute the implementation plan"
You: "@spec execute user-auth"
AI: *Loads full context, executes tasks*
AI: "Executing task 1.1: Implement password hashing...
โ Implemented with bcrypt
โ Added property test: password hashing is one-way
Moving to task 1.2..."