Claude-skill-registry autonomous

Execute 1-2+ hour tasks autonomously with minimal supervision. Requires Task Contract (OUTCOME, EXCLUSIONS, DURATION, GUARDRAILS) upfront, then executes with clarification → plan → autonomous work → session report.

install

source · Clone the upstream repo

git clone https://github.com/majiayu000/claude-skill-registry

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/majiayu000/claude-skill-registry "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/data/autonomous" ~/.claude/skills/majiayu000-claude-skill-registry-autonomous && rm -rf "$T"

manifest: skills/data/autonomous/SKILL.md

Autonomous Mode

Execute extended tasks (1-2+ hours) without supervision after initial clarification.

Prerequisites

User must provide a Task Contract:

OUTCOME: [What success looks like - measurable]
EXCLUSIONS: [What I will NOT do]
DURATION: [Time limit, e.g., "1 hour"]
GUARDRAILS: [Hard limits - code/logic to never touch]

Execution Protocol

Phase 1: Clarification (2-5 mins)

Read relevant files (issues-registry, SOURCE_OF_TRUTH, etc.)
Ask ONLY essential questions (1-3 max):
- Prioritization questions
- Ambiguity in scope
- Items outside GUARDRAILS
User responds briefly

Phase 2: Execution Plan

Show ordered task list:

Will execute in this order:
1. [Task 1] - [estimated time]
2. [Task 2] - [estimated time]
...

Estimated total: X mins
Strategy: [sequential/parallel/hybrid]

Ready to start.

Wait for user "go" or adjustments.

Phase 3: Autonomous Execution

Auto-behaviors:

Auto-invoke skills based on task type (no announcement)
Auto-parallelize independent tasks
Self-heal on errors (2-3 attempts before logging blocker)
Update TodoWrite silently for progress tracking
Batch accumulate learnings/issues in memory

Skill auto-invocation map:

Task Type	Auto-Invoke
Bug fixing	`systematic-debugging`
Large feature (5+ files)	`brainstorming` → `writing-plans`
Multi-file changes	`writing-plans` → `executing-plans`
3+ independent tasks	`dispatching-parallel-agents`

Error handling - Self-Heal First:

Error encountered
    ↓
Attempt 1: Obvious fix
    ↓
Fail? → Attempt 2: Alternative approach
    ↓
Fail? → Attempt 3: Different angle
    ↓
Fail? → Log as BLOCKER, continue other tasks

No interruptions except:

Genuine blocker (all approaches failed)
GUARDRAILS violation detected
DURATION limit reached

Phase 4: Session End Report

## AUTONOMOUS SESSION COMPLETE

**Duration:** X mins | **Progress:** Y% toward OUTCOME

### Completed
- ✅ [task 1]
- ✅ [task 2]

### Remaining
- ⏳ [task 3]

### Blockers (Need Your Input)
- 🚫 [blocker]: Tried [approach 1, 2, 3], all failed because [reason]

### Files Changed
- `path/file.ts` (lines X-Y): [what changed]

### Verification
- Type check: ✅ passed
- Build: ✅ passed
- Tests: [status]

### Knowledge Updates
- `learnings.md`: +N entries
- `issues-registry.md`: N bugs closed/updated
- `SOURCE_OF_TRUTH.md`: [section updated]

### Next Session Recommendation
[What to tackle next based on progress]

Mid-Session Commands

User can send:

```
/status
```
- Brief progress update without stopping
```
/stop
```
- Halt immediately, give session report

Respond briefly to

/status

(2-3 lines), then continue working.

Bypassed Requirements

In autonomous mode, the following normal requirements are BYPASSED:

Bypassed	Why
CLARITY GATE prompts	Task Contract provides clarity
CHECKPOINT every 3 tasks	No interruptions by design
5-section reports per task	Session-end report only
"Quote the CLARITY GATE"	Not needed
Ask before parallel agents	Auto-parallelized

Still Enforced	Why
VERIFICATION before "done"	Quality control
Type check after changes	Catch errors early
GUARDRAILS respect	Safety boundary
Knowledge file updates	Done at session end

Guidelines

DO:

Work silently and continuously
Accumulate blockers, report at end
Respect GUARDRAILS absolutely
Self-heal errors before escalating
Type check after every file change
Update TodoWrite for progress
Parallelize independent work

DON'T:

Ask questions during execution phase
Stop for checkpoints
Touch code in GUARDRAILS
Report 1-sentence updates
Wait for approval between tasks
Ignore errors (self-heal first)

Trust Building Progression

Phase	Duration	Advance After
Training	30 mins	3 successful sessions
Short	1 hour	5 successful sessions
Medium	2 hours	3 successful sessions
Extended	3+ hours	Earned trust

Start small, build confidence, expand scope.

Example Session

USER:
AUTONOMOUS MODE

OUTCOME: All CRITICAL bugs in issues-registry.md fixed and verified
EXCLUSIONS: Not fixing MEDIUM/LOW, not adding features
DURATION: 1 hour
GUARDRAILS: Don't touch payment logic, don't change DB schema

CLAUDE:
I see 5 CRITICAL bugs. Questions:
1. BUG-003 requires a new API endpoint - is that within scope?
2. Should I prioritize revenue-impacting bugs first?

USER:
1. Yes, new endpoints are fine
2. Yes, revenue first

CLAUDE:
Execution plan:
1. BUG-001 (credit leak) - 15 mins
2. BUG-004 (payment race) - 20 mins
3. BUG-003 (API endpoint) - 15 mins
4. BUG-002, BUG-005 - 10 mins

Strategy: Sequential (bugs depend on each other)
Estimated: 50 mins

Ready to start.

USER:
go

[Claude works for 48 minutes]

CLAUDE:
## AUTONOMOUS SESSION COMPLETE
[Full session report as shown above]

Success Criteria

Session is successful if:

✅ Made measurable progress toward OUTCOME
✅ Stayed within EXCLUSIONS
✅ Respected GUARDRAILS
✅ All code passes type check
✅ Blockers are clearly documented
✅ Knowledge files updated