Dev10x-Guru

Dev10x Claude Plugin

Stop babysitting your AI. Start supervising it.
Join the community: https://www.skool.com/Dev10x-1892/about

---

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.