SkillAgentSearch skills...

autonomous-builder

Full-stack software development agent for design, implementation, testing, and deployment

Install / Use

npx skills add foryourhealth111-pixel/Vibe-Skills --skill autonomous-builder

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

92/100

Category

Operations

Supported Platforms

Universal

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.

Substance
30/30
Structure
20/20
Description
12/15
Adoption
15/20
Freshness
15/15

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

Review

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.

  • 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.

SkillScoreStarsUpdatedFormat
autonomous-builder (this skill)by foryourhealth111-pixel923.4k3mo agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.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.

name: 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):

  1. Fresh Context Per Session - Each session uses brand new context window
  2. File-Based State Persistence - Progress via feature_list.json, not context
  3. Git Commit as State Anchor - Atomic progress units with easy rollback
  4. Browser Automation Testing - Act like human user, verify via UI
  5. Auto-Continue with Delay - 3 second delay between sessions

Core Philosophy

The Autonomous Development Loop:

PLAN -> BUILD -> TEST -> DEBUG -> DEPLOY -> (REPEAT)
  |                                    |
  +------------------------------------+

Key Principles:

  1. Self-Sufficient: No user intervention required during execution
  2. State-Persistent: Recovers from interruptions via .builder/ state files
  3. Multi-Language: Auto-detects and adapts to project technology stack
  4. Incremental: Completes one feature at a time, commits progress
  5. 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):

  1. Project requirements or specification
  2. Target platform/environment (web, CLI, mobile, etc.)
  3. 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

View on GitHub
GitHub Stars3.4k
CategoryOperations
Updated2mo ago
Forks299

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions