Install
$ agentstack add skill-yoniyes-agent-skills-interactive-milestone-orchestration ✓ scanned · ✓ verified, works with Claude Code, Cursor, and more.
Security review
✓ PassedNo issues found. Passed automated security review. · v0.1.0 How review works →
- ✓ Prompt-injection patterns
- ✓ Secret / credential exfiltration
- ✓ Dangerous shell & filesystem operations
- ✓ Untrusted network calls
- ✓ Known-malicious package signatures
What it can access
- ✓ Network access No
- ✓ Filesystem access No
- ✓ Shell / process execution No
- ✓ Environment & secrets No
- ✓ Dynamic code execution No
From automated source analysis of v0.1.0. “Used” means the capability is present in the source — more access means more to trust, not that it’s unsafe.
Verified badge
Passed review? Show it. Paste this badge into your README, it links to the public security report.
Reliability & compatibility
Declared compatibility
Compatibility is declared by the source manifest. End-to-end runtime verification is coming, see below.
We're building live execution health for every listing: tool-call success rate, median latency, uptime, and last-checked timestamps, measured, not self-reported. It isn't live yet, so we don't show numbers we can't stand behind.
How agent discovery & health will work →About
Interactive Milestone Orchestration
Use this skill to preserve an execution style where the agent acts as coordinator: small tasks, delegated implementation, live status, reviewed commits, and a clear stop at the milestone boundary.
Core Rule
When the milestone direction is already approved, execute interactively. Do not create or commit another plan/spec/design document unless the user explicitly asks for one.
Treat plans as working context. Treat docs as product and engineering documentation that must stay current with behavior changes.
Start Of Milestone
- Confirm the milestone name and one-line goal.
- Read the current repo status, relevant docs/ledger, recent commits, and local agent instructions.
- Create or refresh an in-message ledger with tasks, DoD, owner, status, commits, checks, and risks.
- Ask at most one blocking scope question if implementation would otherwise be risky.
- Start the first task once scope is clear.
Do not ask "should I continue?" between tasks after the user has asked to execute the milestone.
Task Loop
For each task:
- Define a small measurable DoD.
- Assign an implementer when subagents are available and delegation is authorized; otherwise execute inline.
- Require focused tests and
git diff --checkfor the task. - Run a spec/DoD review.
- Run a code-quality review.
- Fix review findings before moving on.
- Commit only the task's intended files with a verbose conventional commit.
- Update the live ledger with status, commit hash, commands run, and remaining risks.
Prefer one implementation task per commit. Keep unrelated untracked files unstaged.
Agent Pattern
When using subagents:
- Use a fresh implementer per task.
- Give exact ownership, DoD, files likely touched, validation commands, and commit requirements.
- Remind agents they are not alone in the codebase and must not revert unrelated changes.
- After implementation, dispatch a spec reviewer first, then a code-quality reviewer.
- Do not proceed while either review has unresolved Critical or Important findings.
- Close agents when their work is complete.
Do not dispatch multiple implementation agents that can edit overlapping files.
Ledger Shape
Keep the ledger concise and current:
Milestone:
Goal:
Branch:
Task | Owner | Status | DoD | Commit | Checks | Risks
Update statuses incrementally: pending, in_progress, review, complete, or blocked.
Documentation Rule
Update docs when code changes behavior, routes, APIs, architecture, validation, or known caveats. Update implementation ledgers at task or milestone boundaries.
Do not create extra plan documents as a substitute for execution. Only create planning artifacts when the user explicitly asks for a plan/spec document or when the milestone is genuinely not defined yet.
Verification And Closeout
Before claiming a milestone is complete:
- Run focused checks for changed areas.
- Run the agreed full verification gates when practical.
- Confirm git status and note intentional unrelated files.
- Record docs/ledger updates.
- Halt and show the validated flow, commits, commands, residual caveats, and next milestone boundary.
Do not start the next milestone in the same breath.
Escalation Gates
Pause only when:
- Scope is ambiguous and a reasonable assumption could cause rework.
- A blocker remains after real attempts.
- A task would expand the approved milestone boundary.
- A destructive action is needed.
- Production data, credentials, paid services, or external writes are involved.
Anti-Patterns
Avoid these unless the user explicitly requests them:
- Committing a plan before execution when the milestone is already approved.
- Restarting broad discovery after the milestone sequence is known.
- Letting a generic planning workflow override this interactive style.
- Burying multiple tasks in one large commit.
- Skipping reviews because a task looks small.
- Moving on from a milestone without showing the resulting flow.
Source & license
This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.
- Author: yoniyes
- Source: yoniyes/agent-skills
- License: MIT
Install and usage instructions live in the source repository linked above.
Reviews
No reviews yet, be the first.
Write a review
Versions
- v0.1.0 Imported from the upstream source.