autonomous-feature-developer

name	autonomous-feature-developer
description	Use when a user requests adding a new feature to a webapp project and wants automated implementation with testing and iteration

Autonomous Feature Developer

Overview

An autonomous skill that implements new features in webapp projects with minimal user intervention. Follows a full lifecycle: requirement analysis, planning, implementation, testing, debugging, iteration, and delivery with development report.

Core principle: Complete the feature implementation with automated testing and iteration, delivering a polished, production-ready result with a comprehensive development report.

Architecture

Master-Slave pattern: Master agent coordinates and reviews, subagents execute independent tasks.

User Requirement → Master analyzes & plans → Subagent executes tasks
                  → Master reviews results → Iterate until quality
                  → Final verification → Deliver report

When to Use

• User requests a new feature for a webapp project
• User wants automated implementation with minimal intervention
• Feature requires implementation, testing, and iterative refinement

Required sub-skills: brainstorming, writing-plans, subagent-driven-development, test-driven-development, webapp-testing, systematic-debugging, requesting-code-review, verification-before-completion

Core Workflow

Phase 1: Requirement Analysis

1. Use brainstorming skill to clarify requirements
2. Explore project context (architecture, existing patterns, tech stack)
3. Identify constraints and success criteria

Phase 2: Planning

1. Use writing-plans skill to create detailed implementation plan
2. Break down into independent, testable tasks
3. Define acceptance criteria for each task

Phase 3: Execution

1. Use subagent-driven-development to execute tasks in parallel
2. Apply test-driven-development for each feature component
3. Run webapp-testing for functional verification
4. Use systematic-debugging when issues are encountered

Phase 4: Iteration

1. If tests fail after auto-retry (max 2 attempts): invoke systematic-debugging
2. If debugging cannot resolve: report to user for assistance
3. Iterate until all tests pass or user resolves blocker

Phase 5: Quality Gate

1. Use requesting-code-review for final code review
2. Use verification-before-completion for end-to-end verification
3. Confirm feature meets functional and UX criteria

Phase 6: Delivery

Generate development report in user's language containing:

• Technical approach and implementation path
• Features added and their functionality
• Problems discovered during development
• How problems were diagnosed and fixed
• Test coverage and verification results

Test Strategy

Frontend Testing (Playwright/webapp-testing)

• Basic functionality: page loads, buttons work, forms submit correctly
• Edge cases: empty inputs, special characters, long text, boundary values
• E2E flows: complete user interactions from start to finish

Backend/API Testing

• Run after all frontend tests pass (to conserve LLM API costs)
• Test API endpoints, data persistence, error handling

LLM API Testing

• Execute only after all other tests are fixed
• Verify AI-powered features work correctly
• Check for hallucinations, API errors, response quality

Decision Boundaries

User intervention required for:

• Architecture decisions (how components connect, design patterns)
• System-level operations (file system permissions, environment setup)
• Data security decisions (API key handling, sensitive data)
• Third-party service configuration

Automated (no user intervention):

• Implementation details (how to write code)
• Test scenarios and edge cases
• Bug diagnosis and fix application
• UI/UX refinements within existing patterns
• Code style and formatting

Error Handling

1. Auto-retry (1-2 attempts): Minor issues retry automatically
2. systematic-debugging (3+ attempts): Complex issues use debugging skill
3. User escalation: Cannot resolve → report to user with diagnosis and request assistance

Deliverables

1. Implemented feature: Complete, tested, production-ready
2. Development report: Chinese/Multi-language document containing:
   • Technical path and approach
   • Features added (what and why)
   • Problems discovered (symptoms, root cause, fix)
   • Test coverage and results
   • Verification evidence

Context Management

• Use compress tool regularly to prevent context buildup
• Master agent maintains TodoWrite throughout workflow
• After compression, review TodoWrite to restore context
• Subagents receive only necessary context (no session history)

Quality Standards

Criterion	Target
Functional correctness	100% - all features work as specified
Edge case handling	No crashes on boundary inputs
User experience	Intuitive, no confusing behavior
Code quality	Clean, maintainable, follows project patterns
Test coverage	Key paths covered, no regression

Supported Project Types

Currently optimized for:

• FastAPI + native JavaScript webapps
• Playwright for frontend testing

Adaptable to other tech stacks with minor configuration.