Dev10x.guru | Join Community

Dev10x Claude Plugin

Stop babysitting your AI. Start supervising it.

A Claude Code plugin that gives your AI pre-approved workflows, self-correcting guardrails, and a complete scope-to-merge pipeline — so you can supervise in 5-minute windows instead of hovering over every command.

The problem with AI coding assistants

Permission friction kills autonomy. Every ad-hoc bash command triggers a permission prompt. Every prompt pulls you back to the terminal. Your AI can write code, but it can't ship a commit without asking you 15 times.

Progress is invisible. You walk away for 10 minutes and come back to a wall of terminal output. Or a stalled session waiting for approval. No way to tell at a glance if things are on track.

Attention doesn't batch. You want to give 5 minutes of direction, check in during coffee, and move on. Instead you're hovering — approving every shell command, every file write, every git operation.

How Dev10x solves this

Pre-approved workflows, not ad-hoc scripts

67 skills encapsulate complete dev workflows as slash commands. /commit handles gitmoji, ticket reference, and benefit-focused title — all through pre-approved tool calls that never trigger permission prompts.

When Claude uses /Dev10x:gh-pr-create instead of raw gh commands, every step matches an allow rule. Zero interruptions.

Guardrails that teach, not just block

14 hooks across 5 lifecycle events intercept dangerous patterns before they execute — and redirect the AI toward the approved path:

• validate-bash-command catches && chaining, inline python3 -c, and other patterns that break allow rules → teaches separate calls and uv run --script
• validate-edit-write blocks .env file creation and enforces safe file editing patterns
• ruff-format-python auto-formats Python files after every Edit/Write — no manual formatting step needed
• task-plan-sync persists task state to survive context compaction across long sessions

The hooks carry educational messages. The AI learns from each block. By mid-session, it stops triggering them entirely.

Orchestration that finishes what it starts

Long AI sessions drift. The agent forgets the plan, skips steps, uses raw CLI commands instead of skill wrappers, and produces PRs missing ticket links, Job Stories, or CI verification. You come back to a branch that looks done but isn't merge-worthy.

Dev10x:work-on solves this with a four-phase orchestrator — parse inputs, gather context in parallel, build a supervisor-approved plan from a YAML playbook, then execute with enforced skill routing:

• Playbook-driven plans — every work type (feature, bugfix, PR continuation, investigation) has a default play with ordered steps. Override per-project via YAML without touching plugin code.
• Skill routing enforcement — a hard-wired table maps every shipping action (commit, push, PR, CI monitor, groom) to its skill wrapper. The agent cannot fall back to raw git commit or gh pr create — the table survives context compaction.
• Acceptance verification — the last step in every plan delegates to a structured verification skill that checks CI status, PR state, and working copy before declaring done.
• Pause and resume — walk away mid-session and come back later. Task state persists through context compaction, and deferred work is routed to PR bookmarks or project TODOs.

Dev10x:fanout extends this to multiple issues in parallel — each issue gets the full playbook (branch → implement → test → review → PR → CI → merge), not a collapsed shortcut. Issues run in isolated worktrees to avoid merge conflicts, with dependency ordering so blocking work lands first.

The result: you point at a ticket, walk away, and come back to a groomed branch with atomic commits, a Job Story PR, passing CI, and a clean review — not a half-finished session that needs another hour of hand-holding.

Planning that spans milestones

Single-ticket features are straightforward. Multi-milestone projects — the ones that span bounded contexts, require migration sequencing, and involve three teams — are where AI sessions usually produce shallow plans that miss dependencies.

Dev10x:project-scope turns a parent ticket or free-text description into a structured project with milestones, blocking relationships, and tracker integration (Linear, JIRA, or GitHub Issues). Each child ticket gets acceptance criteria, story point estimates, and clear dependency links so future sessions know what to build next.

Dev10x:ticket-scope goes deeper on individual tickets — technical research, architecture design, component identification, and implementation strategy. The output is a scoping document that replaces ad-hoc implementation decisions with structured planning before code is written.

Dev10x:ddd supports the earliest phase: domain exploration via Event Storming workshops. When a feature spans multiple bounded contexts and the right decomposition isn't obvious, the skill guides structured discovery of domain events, aggregates, and context boundaries — producing models that inform how tickets are split and sequenced.

Together, these skills create a planning chain:

Domain exploration (ddd) → Project decomposition (project-scope)
→ Ticket scoping (ticket-scope) → Implementation (work-on)

Each step produces artifacts (models, tickets, scoping docs) that persist across sessions, so the AI picks up context instead of starting from scratch every time.

A complete scope-to-merge pipeline

Every step produces a precise, artifact-quality message — readable by the next agent in the chain or a human reviewer glancing at their phone:

No step produces wall-of-text. Each output is sized for a Slack preview, a PR comment, or a task list glance.

Learning loops that calibrate to you

Code review findings, commit conventions, and PR feedback flow back into CLAUDE.md rules and session memory. The more you course-correct, the less you need to.

After a few sessions, the AI produces commits, PR descriptions, and code that look like you wrote them — because it learned your preferences, not generic defaults.

Supervise, don't babysit

The plugin is designed around batched attention windows:

1. Scope — point at a ticket, let the AI research and plan
2. Walk away — skills and hooks keep the pipeline moving
3. Check in — task list shows where the session stands
4. Course-correct — give 2 minutes of guidance, walk away again
5. Ship — come back to a groomed branch, clean PR, ready for review

When you pop in during a coffee break, you see a task list — not a wall of terminal output. Each artifact (commit message, PR body, review comment) is concise enough to evaluate in seconds.

Skill families

All skills use the Dev10x: prefix — type /Dev10x:git-commit in the Claude Code CLI to run it. Run /Dev10x:skill-index for the full reference.

Installation

claude plugin marketplace add Dev10x-Guru/dev10x-claude
claude plugin install Dev10x@Dev10x-Guru

Run these in your shell, not inside a Claude Code session — the in-session /plugin slash commands are unreliable for install.

Full installation guide → — prerequisites, dependencies, manual clone, develop branch, and verification.

Why Dev10x?

Why Dev10x → — who it's for, what problems it solves, and how it compares to alternatives.

Community

The Dev10x community on Skool is where plugin users get assistance, request features, and share workflows. If you already have access to this repository, you do not need to join Skool — it is a support and discussion hub, not a gatekeeper for repo access.

Development

Development guide →

Star History