AI agent skills for automated software delivery

DeepDone Skills

Turn requirements into reviewable local commits. A supervisor handles planning, implementation, verification, and fixes - pausing when you need to step in.

End-to-end or one safe step at a time
Durable epic ledgers and verification receipts
No silent push, merge, deploy, archive, or destructive git

Installation

Project

Install into the current workspace.

npx skills add lakesoftai/deepdone-agent-skills --skill '*'

Global

Install once for global skill access.

npx skills add lakesoftai/deepdone-agent-skills --skill '*' -g

Minimum prerequisites

Node/npm with npx

skills CLI available through npx skills

Codex or another skill-capable agent

Git repo initialized

Quickstart

Use the prompt below:

Use $deepdone-orchestrate
Requirements: [describe your requirements here or add link to requirements file]
Mode: one-step

Automate the loop or take one safe step

Let DeepDone keep moving when the task is clear. Take one step when you want control. The same supervisor and gates apply either way.

End-to-end path

Automate the loop

continues while safety gates pass
implements one milestone at a time
commits locally only when mode authorizes

Use $deepdone-orchestrate to implement the following requirements 
end to end: @some-requirements.md

Manual control

Drive one safe step

one transition only
inspect-only for no-edit state reads
direct child skills when stage is known

Use $deepdone-orchestrate.
Requirements: <your goal>
Mode: one-step.

Workflow

Plan, implement, verify, review, commit, hand off

DeepDone moves work through one visible path, with gates before anything becomes a commit or handoff.

Plan
Implement
Verify
Review
Commit
Hand off

Safety

Receipts and hard gates stay visible

Durable state makes long work recoverable. Safety gates make sure lifecycle actions stay explicit.

notes/roadmap.md

Tiny initiative index with one active epic and queued future work for multi-epic tasks.

notes/epics/YYYY-MM-DD-<slug>.md

Active ledger with milestones, decisions, verification log, open loops, and next action.

.deepdone/runs/YYYYMMDD-HHMMSS.jsonl

Supervisor audit trail for looped runs.

.deepdone/STOP

Emergency halt file. If present, DeepDone stops before work continues.

Hard gates

No silent scope expansion
No "done" without verification truth
No commit unless authorized
No push, merge, deploy, archive, destructive git, production mutation, or data deletion without explicit approval
No git add .

Skills

Skills by workflow phase

Supervisor and routing

Orchestrate

deepdone-orchestrate

Start here when you want DeepDone to choose the right next step and keep the work moving safely.

Planning and state recovery

Plan

deepdone-plan

Use this when you have new requirements and want them broken into the right size before coding starts.

Sync

deepdone-sync

Use this when work was interrupted, the thread got long, or you need DeepDone to figure out what is really current.

Advance

deepdone-advance

Use this when one large phase is done and you want to move to the next planned phase.

Decision and implementation

Decide

deepdone-decide

Use this when the task needs a technical choice before coding, such as picking an approach, library, API, or migration path.

Implement

deepdone-implement

Use this when the next piece of work is clear and you want DeepDone to make the code change.

Quality gates and repair

Verify

deepdone-verify

Use this when code changed and you want the smallest useful checks run before calling it done.

Review

deepdone-review

Use this when the change is built and verified, and you want a skeptical code review before commit or handoff.

Fixup

deepdone-fixup

Use this when review found clear issues and you want DeepDone to fix them without expanding scope.

Commit, handoff, and archive

Commit

deepdone-commit

Use this when verified work is ready to become a clean local commit.

PR

deepdone-pr

Use this when a local commit is ready and you want a pull request / merge request draft, release notes, or CI inspection.

FAQ

Is DeepDone an autopilot?

No. DeepDone is bounded automation. The orchestrator can keep moving while state is clear and gates pass, but it stops for ambiguity, unsafe actions, risky judgment, missing acceptance criteria, unexpected dirty files, or unauthorized lifecycle actions.

What should I run first?

Install the skills, then start with $deepdone-orchestrate. Use Mode: end-to-end for a normal implementation run, Mode: one-step for one transition, or Mode: inspect-only to classify state without edits.

What does end-to-end actually do?

It runs the workflow from intake toward a local commit, bounded by safety gates. It does not silently push, merge, deploy, archive, or mutate production.

Can I use a single skill manually?

Yes. Use direct child skills when you already know the workflow stage: verify for checks, review for local diff review, commit for commit candidate or local commit work, and pr for PR/MR handoff.

Do I always need to use the DeepDone skills?

Not, of course. For small tweaks or side tasks you may still prefer normal prompts in your agent. Use DeepDone only when it helps.

Can I mix DeepDone skills with other skills?

Yes. Just like with other skills, you may use them in combinations.

What happens if work is interrupted?

Run the orchestrator again with one-step or inspect-only, or use the sync skill. DeepDone will help you to get started when you return to the project after a while.

Will it push, merge, deploy, or change production?

No. Those actions are never implicit. Push, merge, deploy, archive, destructive git, production mutation, and data deletion require explicit approval.