What does this skill do, and when should you use it?
dev is a skill inside the myclaude repository, located at skills/dev/SKILL.md. It orchestrates a 7-step development process: the user first picks allowed backends (codex/claude/gemini), requirements are clarified through questioning, codeagent-wrapper performs deep technical analysis, a development plan is generated and confirmed, then tasks are executed in parallel with deterministic backend routing by task type (default/ui/quick-fix). All code changes must go through codeagent-wrapper — the orchestrator is forbidden from editing files directly. The workflow ends with a mandatory validation that every task reaches at least 90% unit-test coverage, with up to two rounds of additional tests if not.
Step 0 uses AskUserQuestion to let the user multi-select allowed backends; Step 1 runs 2-3 rounds of targeted questions on functional boundaries, inputs/outputs, constraints and test expectations, then creates a task list with TodoWrite; Step 2 invokes codeagent-wrapper via Bash exclusively to analyze the codebase, producing context, option trade-offs, technical decisions and 2-5 parallelizable tasks (each with a type, file scope, dependencies and test command), plus UI-work detection; Step 3 invokes the dev-plan-generator agent to produce dev-plan.md and requires explicit user confirmation; Step 4 submits all tasks in one codeagent-wrapper --parallel call, routing backends by type (default→codex, ui→gemini, quick-fix→claude, with codex→claude→gemini fallback when a preferred backend isn't allowed); Step 5 validates each task's coverage is ≥90%, requesting more tests (max 2 rounds) otherwise; Step 6 outputs a completion summary with the task list, per-task coverage and key file changes.
- Claude Code users who want a feature taken from clarification to completion automatically, rather than manually driving the AI step by step
- Teams with Codex, Claude and Gemini CLIs all installed who want regular development, UI work and quick fixes automatically dispatched to the most suitable backend
- Engineers with a hard coverage requirement who want the workflow itself to block any delivery below 90% test coverage
- Mid-sized requirements containing several independent sub-features that can be split and executed concurrently to reduce wall-clock time
- Developers who want a human checkpoint before execution — the flow enforces explicit user approval at Step 3
How do you install this skill?
- Core execution depends on overseas CLI services (codex/claude/gemini); verify local backend installation and availability before use — reachability from mainland China is a real risk.
- All code modifications are delegated to the external codeagent-wrapper whose permission scope, sandboxing and rollback are not disclosed in the skill files; trial on a small scope with version control enabled before production use.
- The mandatory 90% coverage threshold may cause over-testing or extra rounds on trivial tasks; adjust acceptance criteria to project standards.
- Publisher identity is unverified and the skill has no standalone version/changelog; updates overwrite from the latest repo release — back up custom modifications.
- Backend trait claims (e.g., 'codex stable', 'gemini for UI') are unsourced author assertions, not verifiable facts.
- Shell / CLI
- Local filesystem
codeagent-wrapperCodex CLIClaude CLIGemini CLI
Run the interactive installer: npx github:stellarlinkco/myclaude; use npx github:stellarlinkco/myclaude --list to see installable items (dev is listed as an individual skill); use --update to refresh installed modules from GitHub; use --install-dir ~/.claude --force for a custom directory and overwrite. After installation, skills live under ~/.claude/skills/. The source does not document manual installation steps for this skill file alone.
tmp="$(mktemp -d)"
git clone --depth 1 https://github.com/stellarlinkco/myclaude.git "$tmp"
mkdir -p ~/.claude/skills
cp -R "$tmp/skills/dev" ~/.claude/skills/
rm -rf "$tmp"Generated from the source repository and skill path; it copies only this skill's folder. If the author's install steps above differ, follow those first. To scope it to one project, replace ~/.claude/skills with that project's .claude/skills.
How do you use this skill?
Trigger the /dev workflow in Claude Code. The first run prompts for backend selection (multi-select codex/claude/gemini; choosing only codex forces every task, including UI and quick fixes, onto codex), then moves into requirement clarification. Prerequisites: codeagent-wrapper installed, plus at least one usable backend CLI (Codex needs codex e, --, -C, resume; Claude needs --output-format stream- and -r; Gemini needs -o stream-, -y, -r). Individual parallel tasks time out after 2 hours by default, configurable via CODEX_TIMEOUT.
What are this skill's strengths and limitations?
- End-to-end coverage: clarification → analysis → planning → parallel execution → coverage validation → summary
- Hard 90% unit-test coverage gate with automatic re-test requests (up to two rounds)
- Deterministic multi-backend routing by task type, with a user-constrained allowed set
- Tasks split into 2-5 natural functional units executed in parallel, reducing total time
- All changes flow through codeagent-wrapper; the orchestrator never edits files directly, keeping behavior auditable
- Hard dependency on codeagent-wrapper and at least one backend CLI (Codex/Claude/Gemini); it cannot run without them
- Relies on Claude Code-specific tools (AskUserQuestion, TodoWrite, agent invocation), so porting to other Agent Skills clients requires rework
- Even trivial changes must pass through all 7 steps — backend selection and requirement clarification are mandatory — which can be heavy for one-line fixes
- No standalone test suite or benchmark data in the source; the practical cost of hitting 90% coverage is unverified
- AGPL-3.0 licensing constrains commercial integration; commercial use requires contacting [email protected]
How does this skill compare with similar options?
Side by side with related skills; every score comes from the same FSRS standard.
| Skill | FS score | Stars | Last updated | License |
|---|---|---|---|---|
| Dev End-to-End Development Workflow this page | 43 · Not recommended | ★ 2.8k | 5mo ago | AGPL-3.0 |
| Codeagent Multi-Backend Orchestration Skill | 51 · Use with care | ★ 2.8k | 5mo ago | AGPL-3.0 |
| OmO Multi-Agent Orchestrator | 46 · Use with care | ★ 2.8k | 5mo ago | AGPL-3.0 |
| do — Feature Development Orchestrator | 47 · Use with care | ★ 2.8k | 5mo ago | AGPL-3.0 |
| Multi-Agent Architecture Patterns | 55 · Use with care | ★ 18k | 13d ago | MIT |
The same repository also ships /do (the recommended 5-phase feature development flow with codeagent orchestration) and /omo (multi-agent orchestration with intelligent routing). Per the README's scenario guide, /do is the default for feature development, while /code and /debug suit simple tasks. dev's distinguishing position is the extreme-lightweight end-to-end flow with a hard 90% coverage gate; choose /do if you don't need that enforcement.
How did FollowSkills review this skill?
The skill mandates all code changes go through codeagent-wrapper and forbids direct Edit/Write, and forces user confirmation via AskUserQuestion at Steps 0/1 (backend choice, requirements, plan approval); external effects and data flow are largely visible. Deducted for: execution fully delegated to external CLI backends (codex/claude/gemini) whose permissions, isolation and rollback are not described in the skill files; wrapper provenance/behavior not shown in this path's evidence; broad execution surface without least-privilege or recovery disclosure.
Internally largely self-consistent: steps, routing rules (default→codex, ui→gemini, quick-fix→claude) and fallback priority align; error handling covers wrapper failure, insufficient coverage, dependency cycles, timeout and backend unavailability. Deducted for: key paths unverified statically; a blanket 90% coverage threshold may conflict on trivial tasks; coverage-retry loop and user feedback paths not fully bounded; repo CI tests target the Go wrapper, not this skill's key paths.
Scenario clear (end-to-end feature development), trigger explicit (/dev command), task typing (default/ui/quick-fix) well defined. Deducted for: no declared non-fit boundaries (non-code tasks, environments lacking backend CLIs); core function depends entirely on overseas AI CLIs (codex/claude/gemini), a real reachability risk from mainland China; no Chinese-language support disclosed in the skill itself.
Clear layered structure (constraints, steps, error handling, quality standards) plus a detailed subagent template with quality checklists. Deducted for: no per-skill versioning or changelog; codeagent-wrapper install prerequisites live in the repo README, not self-contained in the skill; publisher identity unverified with maintenance/update path only indirectly evidenced; AGPL-3.0 license clear but commercial licensing contact mixed into the OSS repo.
Claims a full clarify→analyze→plan→parallel-execute→coverage-validate loop; parallelization and backend routing are plausible cost/benefit arguments. Deducted for: no verifiable representative outputs under static review; all value depends on external codeagent-wrapper and multiple paid AI backends; marginal value over using Claude Code directly is unevidenced; the 90% coverage commitment is unproven.
Auditable primary material includes full skill instructions, subagent definition, repo-level CI workflows (Go tests + coverage) and installer. Deducted for: CI covers the Go wrapper, not this skill's workflow, so key-path reproduction is not possible from files; fact/inference not separated (backend 'stable/high quality' claims are unsourced); no third-party corroboration.
Open a dimension to read why it scored that way
Evidence confidence：Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.
See the full review method →