From api-dev
End-to-end orchestrator for a Notion task in core-web-api: runs api-dev:plan → human checkpoint → api-dev:execute → human checkpoint → commit/push/PR → api-dev:pr-signoff. Two explicit checkpoints (plan approval, commit approval); everything else is automated.
How this skill is triggered — by the user, by Claude, or both
Slash command
/api-dev:shipopusThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Chains the 3 `api-dev` skills in sequence with **two explicit human checkpoints**. The goal: ship a Notion task end-to-end with minimal friction, while keeping the human in control of the two decisions that matter (is the plan good, and is the code ready to commit).
Chains the 3 api-dev skills in sequence with two explicit human checkpoints. The goal: ship a Notion task end-to-end with minimal friction, while keeping the human in control of the two decisions that matter (is the plan good, and is the code ready to commit).
Input: $ARGUMENTS — Notion URL or page ID.
If missing, abort with:
Usage: /api-dev:ship <notion-url-or-page-id>
[IA] Step 1 — Pre-flight (branch, status, doppler auth)
[IA] Step 2 — Invoke api-dev:plan → writes plan-<TICKET>-<slug>.md
[IA] Step 3 — Present plan summary
⏸️ CHECKPOINT 1 (human): approve plan / edit / cancel
[IA] Step 4 — Invoke api-dev:execute → branch + migration + specs + code + rubocop + undercover
[IA] Step 5 — Present execution report + diff preview
⏸️ CHECKPOINT 2 (human): approve commit / review diff / cancel
[IA] Step 6 — Commit + push + gh pr create
[IA] Step 7 — Invoke api-dev:pr-signoff → CI + Notion update
[IA] Step 8 — Final report with PR URL
Total human touchpoints: 1 invoke + 2 approvals. Everything else is automated.
Run in parallel:
git branch --show-current
git status --porcelain
git fetch origin main --quiet
doppler --version
gh auth status
Validate:
doppler not installed → abort with install instructions.gh not authenticated → abort: "Run gh auth login first."<X>. Continue here or switch to main? (continue/main/cancel)"api-dev:planUse the Skill tool to invoke the planner:
Skill: api-dev:plan
Args: <notion-url from $ARGUMENTS>
The planner will:
plan-<TICKET>-<slug>.md.Capture: the plan file path, the analyzed classification, the ticket ID, and any Open Questions the planner flagged.
Show the user:
📋 Plan generated: plan-<TICKET>-<slug>.md
Summary:
Ticket: <TICKET>
Title: <title>
Type: <feature|bugfix|...>
Module: <module>
Audience: <audience>
Components: <list>
Migration: <yes/no>
ENV vars: <list or "None">
Top 3 decisions made:
1. <from planner>
2. <from planner>
3. <from planner>
Open questions (blockers):
<list or "None">
If there are Open Questions the planner flagged as blockers, stop and present them. Do NOT proceed — ask the user to resolve them first.
Ask:
What next?
1. Approve plan and start implementation
2. Edit plan (I'll open it in your editor)
3. Cancel
Your choice:
$EDITOR plan-<TICKET>-<slug>.md. After the user saves, re-read the plan and re-present the summary. Then ask again.api-dev:executeSkill: api-dev:execute
Args: <plan file path>
The executor will:
main.annotaterb.rubocop -A + manual fixes.undercover --compare origin/main (blocking gate).Capture: the execution report (files created/modified, specs status, coverage, rubocop status, ENV vars applied).
If the executor stops (3 failure limit, plan blocker, undercover blocked) → propagate the stop to the user. Do NOT proceed to commit.
Show:
✅ Execution completed
Files created (<N>):
- <list>
Files modified (<N>):
- <list>
Migration: <ran / not needed>
Specs: <N> passing, 0 failing
Coverage: <% global> / <diff: clean>
Rubocop: clean
ENV vars: <list or "none">
Manual review recommended:
- <from executor>
Then show the diff summary:
git diff main...HEAD --stat
Offer to show the full diff:
Show full diff before committing? (y/n)
If yes → git diff main...HEAD (user reviews).
Propose the commit message (built from the plan):
Proposed commit:
[<TYPE>] <Notion title> - <TICKET>
Co-Authored-By: Claude <[email protected]>
What next?
1. Commit with this message, push, and open PR
2. Edit commit message
3. Review more (stop here, I'll commit manually)
4. Cancel (rollback: discard implementation branch)
Your choice:
[<TYPE>] <desc> - <TICKET> format). Validate before committing.git reset --hard origin/main
git clean -fd
git checkout main
git branch -D <feature-branch>
Then exit.git add <files from execution report>
git commit -m "$(cat <<'EOF'
[<TYPE>] <title> - <TICKET>
Co-Authored-By: Claude <[email protected]>
EOF
)"
git push -u origin <branch>
gh pr create --base main \
--title "[<TYPE>] <title> - <TICKET>" \
--body "$(cat <<'EOF'
## Summary
<from plan's Summary section>
## Ticket
[<TICKET>](<Notion URL>)
## Changes
<from execution report's files created/modified>
## Checklist
- [x] Specs written before implementation (RED → GREEN)
- [x] All Business Rules covered by specs
- [x] Multi-tenant isolation verified (where applicable)
- [x] Undercover diff coverage: clean
- [x] Rubocop: clean
- [x] ENV vars synced (if any)
## Test plan
- [ ] Reviewer runs: \`doppler run --config test -- bundle exec rspec <paths>\`
- [ ] Reviewer verifies ENV vars in Doppler prd (if listed in plan)
EOF
)"
Capture: the PR URL from gh pr create output.
api-dev:pr-signoffSkill: api-dev:pr-signoff
Args: <notion-url or ticket ID>
The signoff will:
bin/ci.undercover (redundant safety check).Code Review.━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🚀 Ship completed
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Ticket: <TICKET> — <title>
Branch: <branch name>
PR: <PR URL>
Notion: <previous status> → <new status>
Pipeline:
Plan: ✅ approved by human
Execute: ✅ <N> files created, specs passing, coverage clean
Commit: ✅ <commit SHA>
Push: ✅ to origin/<branch>
PR: ✅ opened against main
bin/ci: ✅
Undercover: ✅ diff covered
Notion: ✅ moved to Code Review
Reviewers can now review:
<PR URL>
Manual follow-ups (from executor report):
<list or "None">
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
undercover — if execute reports uncovered lines, ship stops.yes confirmation before destructive reset — don't assume./api-dev:ship/api-dev:plan./api-dev:execute <plan.md>./api-dev:pr-signoff./api-dev:ship is for the full new-task happy path. For everything else, use the individual skills.
Provides behavioral guidelines to reduce common LLM coding mistakes, focusing on simplicity, surgical changes, assumption surfacing, and verifiable success criteria.
Searches, retrieves, and installs Agent Skills from prompts.chat registry using MCP tools like search_skills and get_skill. Activates for finding skills, browsing catalogs, or extending Claude.
Creates, edits, and optimizes skills for Claude Code, including drafting, evaluating with test prompts, iterating on performance, and improving skill descriptions for better triggering accuracy.
npx claudepluginhub kodimtech/claude-code-plugins --plugin api-dev