claude-dev-agents

Structured task execution with quality gates, parallel waves, and pm-db tracking — solo or with multi-agent teams (--team). Use this skill when the user wants to execute a task list, run implementation tasks, start building a feature from a plan, run tasks in parallel with a team of agents, or says things like 'execute these tasks', 'start building', 'run the implementation', 'execute the plan', 'execute with a team', or 'start phase execute'. Also triggers on '/start-phase execute' and '/start-phase-execute-team' commands.

Assess and score codebase architecture health — layer separation, SOLID compliance, module coupling (FAN-IN/FAN-OUT), circular dependencies, drift from documented patterns. Use whenever the user asks to assess/review/grade architecture quality, wants an architecture score, or asks how healthy the codebase's architecture is. Analysis-only report + refactoring tasks; for docs-vs-code drift use document-hub-analyze.

Deep analysis of codebase for code duplication. Detects exact, structural, and pattern-level duplicates, generates comprehensive reports with refactoring suggestions and metrics.

Use when Mark reports a bug by pasting a raw artifact with little or no prose — a stack trace, an HTTP request/response trace (URL + method + status like 500/403/404/502), a console/React/Prisma error, a ChunkLoadError, a shell error, or a screenshot of a visual defect — or when he says things like 'still failing', 'clicking X does nothing', 'no inline editor on the rendered page', 'do we have local postgres/pgvector?', or 'identify the true error'. This is the front-to-back debugging procedure — extract the trigger and reproduction from terse input, probe whether the underlying plumbing even exists, localize by contrasting known-good vs broken, and drive to a durable root cause rather than a workaround. Reach for this BEFORE proposing any fix.

Deep analysis of codebase vs documentation alignment (cline-docs/). Detects drift, identifies undocumented code, extracts missing glossary terms, and provides actionable recommendations without making changes. Use this skill when the user asks "are the docs up to date", "check documentation quality", "what's missing from the docs", or wants a read-only audit before deciding what to update. For actually making changes, use document-hub-update instead.

Bootstrap a new project's documentation hub by creating the four core documentation files (systemArchitecture.md, keyPairResponsibility.md, glossary.md, techStack.md) with initial content based on codebase analysis.

Read and summarize the current state of the documentation hub (cline-docs/). Provides a quick overview of system architecture, module responsibilities, technology stack, and glossary terms. Use this skill whenever the user asks about the project's documentation, wants to understand the architecture, asks "what does this project do", "show me the docs", or needs a quick onboarding summary. Also use before starting work to understand project context.

Comprehensive review and update of the documentation hub (cline-docs/). Analyzes recent code changes, detects drift, validates structure, and proposes specific updates to keep documentation synchronized with the codebase. Use this skill whenever the user says "update the docs", "sync documentation with code", "docs are outdated", or after significant code changes. For read-only analysis without changes, use document-hub-analyze instead.

Use whenever you're about to present Mark with consequential choices, questions, or tradeoffs — structure them as a numbered or lettered menu so a bare reply counts as a full selection, and use this to read his terse picks. Triggers on one-token replies that only resolve against a labeled list you just gave ('go with B', 'lets go with 2', 'run option B', 'c one big commit'), picks carrying a rider ('option 1 and update envs when your done', '1. yes, and execute it'), multi-item sweeps answering every numbered point at once ('1. yes 2. thats fine 3. just aws 4. whats the mcp server? 5. minimal'), ranged picks with a because-clause scope-cut ('do 1-3, 4 wont be needed because...'), and Mark authoring his own numbered decision list to apply across a spec. Format choices as a menu — a bare letter is uninterpretable unless you offered the list first.

Complete feature workflow - from planning to execution with PM-DB tracking. Use when the user wants to build a new feature end-to-end ('build this feature', 'implement this', 'new feature', 'add this capability', '/feature-new'), or to resume one: --continue picks up interrupted feature work from task-list.md with PM-DB tracking intact, skipping completed tasks — use for 'continue/resume the feature', 'pick up where we left off', 'what's left on this feature', or a dropped session (pure status recall: memory-bank-read). Orchestrates spec-plan → spec-review → start-phase-plan → pm-db → start-phase-execute into one workflow with human checkpoints. Use it whenever someone describes a new feature they want built from scratch.

Use when Mark wants large or mechanical work fanned out across his machine fleet, or wants long-running/background/remote agents monitored. Triggers on 'distribute among the fleet', 'delegate with tmux and worktrees', 'kick it off fan them out', 'offload to mac-mini, desktop just orchestrate', 'check on the agents every 5 min', 'is it done its been some hours', 'are we ready to delegate', or any dispatch to background workers. This is Mark's dispatch→snapshot→poll→escalate→checkpoint loop — fan independent work to workers (local box orchestrates), hand each a precise state snapshot, then poll on a fixed cadence with trustworthy liveness proxies, error-signature buckets, and hard stop/escalation thresholds — never blocking or assuming success.

Work with GitLab Enterprise as a maintainer via glab — check pipeline status, diagnose and fix failing CI (build/test/lint), push the fix and wait for green, and handle MR review threads, approvals, and change requests. Use for "check the pipeline", "why is CI failing", "address review comments", "approve this MR", or any mention of glab, a self-hosted GitLab MR, pipeline, or job log. Prefer this over raw glab commands — it handles auth checks, repo detection, paging, and the diagnose→fix→push→re-monitor loop.

Shrink large text before it travels or gets re-read, using the headroom MCP (mcp__headroom__headroom_compress / _retrieve / _stats). Use it BEFORE pasting a 200+ line blob (logs, files, search results, JSON) into a subagent Task prompt, stashing content you'll re-read later, or re-carrying big output through a pipeline — even if the user never says "compress." Every compress returns a hash headroom_retrieve expands, so use it in reverse too: handed a `hash=` marker, recover exact details from the original. NOT gzip/zip, image/video compression, making code concise, or database column compression.

Mastra Agent development guide - creation, tools, memory, networks, processors, guardrails, voice, and structured output patterns

Mastra Deployment and Server guide - server adapters, authentication, middleware, client SDK, cloud providers, and production deployment

Ultimate Mastra Framework development toolkit for agent orchestration, workflow design, and MCP integration

Mastra Evaluation and Testing guide - built-in scorers, custom scorers, datasets, experiments, and CI integration

Mastra MCP integration guide - MCPClient for consuming tools, MCPServer for exposing agents/workflows, tool creation, and publishing

Mastra Memory system guide - storage backends, message history, observational memory, working memory, semantic recall, and thread management

Strategic planning and team orchestration for Mastra development - analyzes tasks, designs team compositions, creates execution plans, and coordinates agent splits

Mastra RAG pipeline development - document processing, chunking, embedding, vector databases, retrieval, GraphRAG, and agent integration tools

Mastra Streaming patterns - agent streams, workflow streams, tool streaming, SSE events, and AI SDK integration for React/Next.js UIs

Mastra Workflow development guide - DAG composition, control flow, suspend/resume, HITL, time travel, state management, and streaming

Mastra Workspace development - filesystem providers, sandbox execution, skills system, search/indexing, and tool configuration

Bootstrap a new project's Memory Bank by creating the six core files with templates and gathering initial project information from the user. Also the entry point to initialize/set up project documentation in a new or freshly cloned repo — including bootstrapping BOTH Brain systems (Memory Bank + Document Hub) at once.

Quick overview of Memory Bank state. Validates structure, reads all 6 files in hierarchical order, and summarizes with staleness warnings. Use for "where did I leave off", "what's the project status", "catch me up", "what was I working on", "summarize the memory bank", returning to a project after time away, or checking if the memory bank needs updating.

Review and update Memory Bank files. Full mode reads all 6 files and proposes targeted updates; --quick mode (formerly memory-bank-sync) updates only activeContext.md + progress.md. Full mode for "update the memory bank", "refresh documentation", "sync all memory bank files", architecture changes, or major milestones. Quick for "quick save", "save my progress", "mark this as done", "update where I left off", or recording a finished task without a full review.

Create diagrams on Miro boards using the Miro MCP tools — flowcharts, UML class/sequence diagrams, and ERDs. Use whenever the user wants to diagram or visualize anything on a Miro board: architecture, system flows, database schemas, process maps, interaction sequences — or just says "diagram this" with the Miro MCP connected. For multi-element layouts (diagrams + text + tables + metrics), use miro-infographic instead.

Create visual infographics on Miro boards by composing diagrams, documents, and tables into cohesive layouts — stats dashboards, comparison layouts, process overviews with data, executive summaries. Use whenever the user wants an infographic, dashboard, visual summary, one-pager, comparison chart, or metrics overview on Miro, or asks to present data visually on their board. For a single diagram (flowchart, ERD, sequence) use miro-diagram; use THIS skill when multiple elements — diagrams + text + tables + metrics — compose together.

Deep research and architecture design for new product development

Project management database for tracking specs, phases, tasks, and execution runs. Use this skill whenever the user asks about project status, wants to track feature work, needs a dashboard of progress, wants to import specs from /spec-plan, or mentions tracking tasks, phases, or runs. Also use when the user says things like 'what's the status', 'how's the project going', 'track this work', 'show me progress', or 'import my specs'.

Use whenever an agent (or you) is about to claim work is done/fixed/shipped/passing, or when Mark says 'ready?', 'done?', 'did it work?', 'still failing', 'is the live URL responding?', 'check the deploy status', or wants to confirm a fix before pushing. Treat every completion claim, green CI, and passing test as UNPROVEN until the real artifact is exercised end-to-end — drive the actual running app at its real URL/UI/API, confirm the deployed revision is actually live, verify the mutating side-effect (email/queue/DB row) truly fired, gate every forward step on an explicit green signal, audit coverage across the whole surface, and reconcile against the system of record. Then name the specific residual defect with expected-vs-actual.

Use when Mark points at a concrete reference as the feature spec instead of describing behavior — a live product ('an inline editor like editor.js', 'much like openclaw.ai'), an internal subsystem ('the OTP from sentient-monorepo is the pattern we should match'), or a library's structure ('setups similar to CASL'). On 'build it like THAT', 'same as X', 'mimic/replicate X': the named reference IS the executable spec — go observe it and let its real behavior define correct.

Use at the START of anything sizable, BEFORE writing code — when Mark says 'lets start the planning', 'I want to do some deep research', 'what does complete look like / what tickets remain / what are our current gaps', or 'do we already have a harness for this / is there a system we can use?'. Inventory what exists, scope the gap, persist research as artifacts, gate phases on human checkpoints. Decides WHETHER and HOW to enter the execution skills (start-phase-plan, feature-new); run it first.

Use when work is genuinely ambiguous in a way that changes the plan, big/multi-part/underspecified enough to balloon context, or when the orchestrator's window nears the ~200k cliff. Fires when Mark says 'this is a big one', 'what do you need from me before you start', 'dont drag the whole context through this', 'should we split this up' — or when one thread does both the planning AND the execution. Triage fast, ask only the few DECISIVE questions, treat the window as a finite budget, and hand each worker a minimal scoped snapshot. Not a hard gate — small clear tasks just proceed.

Automated security vulnerability scanning for Python and JavaScript/TypeScript codebases. Detects OWASP Top 10 vulnerabilities, hardcoded secrets, injection risks, and known CVEs with actionable remediation guidance.

Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.

Pre-planning and research for feature specs with scope-aware tiered output (quick task-list, standard FRD+TR, full FRD/FRS/Gherkin/TR). Use to spec out a feature, prep requirements/FRD, do pre-planning research, or 'plan before we build'. To critique an existing spec, use spec-review.

Validate, critique, and iterate on generated specifications. Use for "review this spec", "critique the FRD/FRS", "is this spec ready to build?", or folding user feedback into a spec produced by spec-plan before execution begins.

Mode 1 - Strategic planning with human approval before execution. Use this skill whenever a user wants to plan, review, or strategize a task list before executing it. Triggers on: "plan this", "review these tasks", "let's plan before building", "/start-phase plan", or any request to analyze a task list for parallelism, complexity, or agent delegation. Always use this before /start-phase-execute for non-trivial work.