autonomous-builder
Full-stack software development agent for design, implementation, testing, and deployment
Install / Use
npx skills add foryourhealth111-pixel/Vibe-Skills --skill autonomous-builderInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
OperationsSupported Platforms
Our assessment of autonomous-builder
autonomous-builder scores 92/100 on our quality scale, 204th of 746 Operations skills we index (top 28%).
Its SKILL.md is 39 KB long, well organised into 75 sections with 40 code examples: a thorough specification that gives an agent plenty to work with.
With 3,433 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 3 months ago, so autonomous-builder is actively maintained.
- Our last check on 2026-10-27 found the source still online.
- It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
ReviewOur scan of the whole file found 3 patterns worth reviewing before you install autonomous-builder. An AI review judged it risky: The skill instructs creation of an auto-generated supervisor script that launches Claude with `--dangerously-skip-permissions`, bypassing all user confirmations for unattended operation.
- mediumDisables the agent's permission promptsline 425
# WARNING: --dangerously-skip-permissions bypasses all user confirmations - mediumDisables the agent's permission promptsline 427
claude --skill autonomous-builder --project "$PROJECT_DIR" --dangerously-skip-permissions - mediumDisables the agent's permission promptsline 437
**⚠️ Security Warning:** `--dangerously-skip-permissions` bypasses ALL user confirmations. Use only in trusted, isolated environments. Ensur…
AI review: risky
- The skill instructs creation of an auto-generated supervisor script that launches Claude with `--dangerously-skip-permissions`, bypassing all user confirmations for unattended operation.
- It explicitly frames `--dangerously-skip-permissions` as part of the normal auto-restart/self-supervision workflow, even though it includes a warning about the flag.
- The auto-continue rules repeatedly specify that user input is not required, including after errors and before proceeding to the next feature, which weakens the agent's safeguards.
AI review by kimi-k2.7-code on 2026-09-30. Automated pattern scan on 2026-09-30. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
autonomous-builder compared with similar skills
All 4 of these similar skills score higher than autonomous-builder; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| autonomous-builder (this skill)by foryourhealth111-pixel | 92 | 3.4k | 3mo ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 8d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.8k | today | CLAUDE.md |
Frequently asked questions
- How do I install autonomous-builder?
- Run
npx skills add foryourhealth111-pixel/Vibe-Skills --skill autonomous-builder. The install tabs above show the steps for each supported agent. - Which AI agents does autonomous-builder work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is autonomous-builder safe to use?
- Our scan of the whole file found 3 patterns worth reviewing before you install autonomous-builder. An AI review judged it risky: The skill instructs creation of an auto-generated supervisor script that launches Claude with
--dangerously-skip-permissions, bypassing all user confirmations for unattended operation. It is Apache-2.0-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand. - Is autonomous-builder still maintained?
- The repository was last updated about 3 months ago, so autonomous-builder is actively maintained.
Skill content
View source on GitHubname: autonomous-builder version: "1.0.0" description: "Full-stack software development agent for design, implementation, testing, and deployment. Use when the user explicitly asks for end-to-end project creation, feature development, bug fixing, or code refactoring." user-invocable: true allowed-tools:
- Read
- Write
- Edit
- Bash
- Glob
- Grep
- WebFetch
- WebSearch
- Skill
- Task
- ToolSearch
- mcp__ide__executeCode
- mcp__ide__getDiagnostics
Autonomous Builder
A fully autonomous software development agent that handles the complete software lifecycle: requirements analysis, architecture design, implementation, testing, debugging, and deployment.
Architecture Pattern: Two-Agent Model
Based on Anthropic's official claude-quickstarts architecture
┌─────────────────────────────────────────────────────────────────┐
│ TWO-AGENT ARCHITECTURE │
├─────────────────────────────────────────────────────────────────┤
│ │
│ SESSION 1: INITIALIZER AGENT │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ • Read requirements / spec │ │
│ │ • Create project structure │ │
│ │ • Generate feature_list.json (200+ tests) │ │
│ │ • Initialize Git repository │ │
│ │ • ✨ Prompt for GitHub URL (optional) │ │
│ │ • ✨ Create README.md & PLANNING.md │ │
│ │ • Commit initial state │ │
│ │ • ✨ Push to GitHub & create issues │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ feature_list.json │
│ (Single Source of Truth) │
│ │ │
│ SESSIONS 2+: BUILDER AGENT (fresh context each session) │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Step 1: Get Context (pwd, ls, git log, progress) │ │
│ │ Step 2: Start/verify server │ │
│ │ Step 3: Verify previous tests (regression check) │ │
│ │ Step 4: Select next "passes": false feature │ │
│ │ Step 5: Implement feature │ │
│ │ Step 6: Browser automation test │ │
│ │ Step 7: Update feature_list.json │ │
│ │ Step 8: Generate workflow report │ │
│ │ Step 9: Git commit + GitHub push │ │
│ │ Step 10: Update progress notes │ │
│ │ Step 11: Clean exit (auto-continue in 3s) │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
Key Design Principles (Official Pattern):
- Fresh Context Per Session - Each session uses brand new context window
- File-Based State Persistence - Progress via feature_list.json, not context
- Git Commit as State Anchor - Atomic progress units with easy rollback
- Browser Automation Testing - Act like human user, verify via UI
- Auto-Continue with Delay - 3 second delay between sessions
Core Philosophy
The Autonomous Development Loop:
PLAN -> BUILD -> TEST -> DEBUG -> DEPLOY -> (REPEAT)
| |
+------------------------------------+
Key Principles:
- Self-Sufficient: No user intervention required during execution
- State-Persistent: Recovers from interruptions via
.builder/state files - Multi-Language: Auto-detects and adapts to project technology stack
- Incremental: Completes one feature at a time, commits progress
- Error-Resilient: 3-strike protocol with automatic recovery strategies
When to Use This Skill
Use this skill when the user explicitly wants this agent to own an end-to-end build or major refactor, such as:
- Starting a new project from a full specification
- Continuing a previously initialized
.builder/project - Driving a broad feature build across multiple implementation steps
- Performing an explicit refactor or modernization effort across the codebase
Use stage assistants or other routed specialists for narrow bug fixes, one-off debugging, or scoped edits that do not need full lifecycle ownership.
Not For / Boundaries
- Security-critical systems without human review
- Production deployments without user confirmation
- Legal/compliance-sensitive code without audit
- Data migration without backup verification
- Infrastructure changes without explicit approval
- System-level operations outside workspace (see SAFETY CRITICAL below)
Required inputs (ask if missing):
- Project requirements or specification
- Target platform/environment (web, CLI, mobile, etc.)
- Preferred language/framework (or auto-detect)
Safety First: All operations that could affect system stability, data integrity, or files outside the workspace require explicit user approval. See SAFETY CRITICAL section below for details.
Quick Reference
Session Continuity (Auto-Resume)
⚠️ Critical for Unattended Long-Running Operation
AUTO-RESUME PROTOCOL:
┌─────────────────────────────────────────────────────────────────┐
│ Session Start │
│ │ │
│ ▼ │
│ Check .builder/state.json exists? │
│ │ │
│ ├─ NO → Initialize new project │
│ │ │
│ └─ YES → Resume from saved state: │
│ 1. Read current_phase │
│ 2. Read current_feature │
│ 3. Read pending_features[] │
│ 4. Continue from last checkpoint │
│ │
│ After each feature completion: │
│ │ │
│ ▼ │
│ More pending features? │
│ │ │
│ ├─ YES → Auto-start next feature (NO user input needed) │
│ │ │
│ └─ NO → All complete! Generate report │
└─────────────────────────────────────────────────────────────────┘
Auto-Continue Rules:
| Condition | Action | User Input Required | |-----------|--------|---------------------| | Feature completed, more pending | Auto-start next | NO | | Error recovered successfully | Continue current | NO | | 3-strike error failed | Skip and continue | NO (unless critical) | | Loop detected & resolved | Resume from checkpoint | NO | | All features complete | Generate final report | NO |
State Persistence After Each Operation:
{
"auto_continue": true,
"resume_token": "feat…[redacted]",
"next_action": "Continue implementing feat-003",
"features_remaining": 3,
"estimated_completion": "2026-02-14T18:00:00Z"
}
Automatic Task Queue
# After completing a feature, automatically proceed:
def on_feature_complete(feature_id: str, state: ProjectState):
"""Called when a feature is marked complete."""
# 1. Save checkpoint
save_checkpoint(state, feature_id)
# 2. Update feature status
state.features[feature_id].status = "completed"
state.features[feature_id].completed_at = datetime.now()
# 3. Check for pending features
pending = [f for f in state.features if f.status == "pending"]
if pending:
# 4. Auto-select next feature (NO user input)
next_feature = select_next_feature(pending, state)
state.current_feature = next_feature.id
state.current_phase = "implement"
# 5. Save state immediately
save_state(state)
# 6. LOG and CONTINUE (not ask user)
log_progress(f"Auto-continuing to {next_feature.name}")
return ContinueAction(feature=next_feature)
else:
# All complete!
return CompleteAction(report=generate_final_report(state))
Resume Message on Session Start:
## 🔄 Session Resume Detected
**Previous Session**: Session #5
**Last Activity**: 2 hours ago
**Current Feature**: feat-003 (User Authentication)
**Phase**: implement (60% complete)
**Pending Features**: 3 remaining
- feat-004: API Rate Limiting
- feat-005: Email Notifications
- feat-006: Final Documentation
**Auto-Continuing**: Resuming feat-003 implementation...
[Proceeding without user input - type "pause" to stop]
Directory Structure
.builder/
├── state.json # Current project state
├── features.json # Feature list with status
├── architecture.md # Design decisions
├── progress.md # Session log
├── errors.json # Error history and resolutions
├── checkpoints/ # Recovery checkpoints
├── auto-continue.{sh,bat,ps1} # Auto-restart script (auto-generated)
└── supervisor.json # Self-supervision config
Skill Recommendations & Router Handoff
⚠️ Skill discovery is advisory. The host router remains the only main-route authority.
ON PROJECT INITIALIZATION:
1. Check for Claude_Skills_中文指南.md in workspace root
2. If found:
- Read and parse skill catalog
- Store available skills in state.json
3. For each feature:
- Analyze feature requirements
- Match against skill catalog
- Add recommended_skills to feature definition as router-handoff suggestions
DURING IMPLEMENTATION:
1. Before each implementation step:
- Check step's invoke_skill field
- Or analyze step for skill match
2. Request router-approved handoff:
- Propose the matched skill to the host router or current route authority
- Use the Skill tool only after that router-authorized handoff or an explicit user request
- Continue with the returned guidance once the handoff is granted
3. Log router-approved skill usage to state.json
Task-to-Skill Mapping (Recommended):
| Task Type | Recommended Skills |
|-----------|--------------------|
| Code review | code-reviewer |
| Data analysis | exploratory-data-analysis, statistical-analysis |
| Visualization | data-artist, matplotlib, plotly |
| ML training | senior-ml-engineer, pytorch-lightning |
| ML evaluation | evaluating-machine-learning-models, shap |
| Scientific writing | scientific-writing, scientific-schematics |
| Debugging | systematic-debugging |
| Documentation | docs-write, writing-docs |
| Architecture | architecture-patterns |
| Bioinformatics | biopython, bio-database-evidence |
| Drug discovery | torchdrug, rdkit, uniprot-database |
Feature with Skill Planning:
{
"id": "feat-001",
"name": "Data Analysis Module",
"recommended_skills": [
{"skill": "exploratory-data-analysis", "phase": "implementation"},
{"skill": "data-artist", "phase": "implementation"}
],
"skill_dispatch_schedule": [
{"step": 1, "action": "Explore data", "invoke_skill": "exploratory-data-analysis", "route
Truncated for display — read the full file on GitHub.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
81.9k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
79.8kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.