Implementing Features

I help you execute production-quality implementations with auto-detected language standards, intelligent agent orchestration, and specification integration.

When to Use Me

Auto-activate when:

• Invoked via /quaestor:implement slash command
• User mentions "build [specific feature]" or "fix [specific bug]" with context
• Continuing implementation after planning phase is complete
• User says "continue implementation" or "resume implementing"
• Coordinating multi-agent implementation of an active specification

Do NOT auto-activate when:

• User says only "implement" or "implement it" (slash command handles this)
• User is still in planning/research phase
• Request is vague without feature details

Supporting Files

This skill uses several supporting files for detailed workflows:

• @WORKFLOW.md - 4-phase implementation process (Discovery → Planning → Implementation → Validation)
• @AGENTS.md - Agent orchestration strategies and coordination patterns
• @QUALITY.md - Language-specific quality standards and validation gates
• @SPECS.md - Specification integration and tracking protocols

My Process

I follow a structured 4-phase workflow to ensure quality and completeness:

Phase 1: Discovery & Research 🔍

Specification Integration:

• Check .quaestor/specs/active/ for in-progress work
• Search .quaestor/specs/draft/ for matching specifications
• Move draft spec → active folder (if space available, max 3)
• Update spec status → "in_progress"

Research Protocol:

• Analyze codebase patterns & conventions
• Identify dependencies & integration points
• Determine required agents based on task requirements

See @WORKFLOW.md Phase 1 for complete discovery process

Phase 2: Planning & Approval 📋

Present Implementation Strategy:

• Architecture decisions & trade-offs
• File changes & new components required
• Quality gates & validation approach
• Risk assessment & mitigation

MANDATORY: Get user approval before proceeding

See @WORKFLOW.md Phase 2 for planning details

Phase 3: Implementation ⚡

Agent Orchestration:

• Multi-file operations → Use researcher + implementer agents
• System refactoring → Use architect + refactorer agents
• Test creation → Use qa agent for comprehensive coverage
• Security implementation → Use security + implementer agents

Quality Cycle (every 3 edits):

Execute → Validate → Fix (if ❌) → Continue

See @AGENTS.md for complete agent coordination strategies

Phase 4: Validation & Completion ✅

Quality Validation:

1. Detect project language (Python, Rust, JS/TS, Go, or Generic)
2. Load language-specific standards from @QUALITY.md
3. Run validation pipeline for detected language
4. Fix any issues and re-validate

Completion Criteria:

• ✅ All tests passing
• ✅ Zero linting errors
• ✅ Type checking clean (if applicable)
• ✅ Documentation complete
• ✅ Specification status updated

See @QUALITY.md for dispatch to language-specific standards:

• @languages/PYTHON.md - Python projects
• @languages/RUST.md - Rust projects
• @languages/JAVASCRIPT.md - JS/TS projects
• @languages/GO.md - Go projects
• @languages/GENERIC.md - Other languages

Auto-Intelligence

Project Detection

• Language: Auto-detect → Python|Rust|JS|Generic standards
• Scope: Assess changes → Single-file|Multi-file|System-wide
• Context: Identify requirements → architecture|security|testing|refactoring

Execution Strategy

• System-wide: Comprehensive planning with multiple agent coordination
• Feature Development: Iterative implementation with testing
• Bug Fixes: Focused resolution with validation

Agent Coordination

I coordinate with specialized agents based on task requirements:

• workflow-coordinator - First! Validates workflow state and ensures planning phase completed
• implementer - Builds features according to specification
• architect - Designs system architecture when needed
• security - Reviews auth, encryption, or access control
• qa - Creates comprehensive tests alongside implementation
• refactorer - Ensures consistency across multiple files
• researcher - Maps dependencies for multi-file changes

See @AGENTS.md for agent chaining patterns and coordination strategies

Specification Integration

Auto-Update Protocol:

Pre-Implementation:

• Check .quaestor/specs/draft/ for matching spec ID
• Move spec from draft/ → active/ (max 3 active)
• Declare: "Working on Spec: [ID] - [Title]"
• Update phase status in spec file

Post-Implementation:

• Update phase status → "completed"
• Track acceptance criteria completion
• Move spec to completed/ when all phases done
• Create git commit with spec reference

See @SPECS.md for complete specification integration details

Quality Gates

Code Quality Checkpoints:

• Function exceeds 50 lines → Use refactorer agent to break into smaller functions
• Nesting depth exceeds 3 → Use refactorer agent to simplify logic
• Circular dependencies detected → Use architect agent to review design
• Performance implications unclear → Use implementer agent to add measurements

See @QUALITY.md for language-specific quality gates and standards

Success Criteria

• ✅ Workflow coordinator validates planning phase completed
• ✅ Specification identified and moved to active/
• ✅ User approval obtained for implementation strategy
• ✅ All quality gates passed (linting, tests, type checking)
• ✅ Documentation updated
• ✅ Specification status updated and tracked
• ✅ Ready for review phase

Final Response

When implementation is complete:

Implementation complete. All quality gates passed.
Specification [ID] updated to completed status.
Ready for review and PR creation.

See @WORKFLOW.md for complete workflow details

---

Intelligent implementation with agent orchestration, quality gates, and specification tracking