Claude Dev Agents

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 the public `orca` CLI to operate Orca-managed worktrees, folder contexts, terminals, repos, automations, worktree comments, and the browser embedded inside the Orca app. Use when the user says "$orca-cli", "use orca cli", "Orca worktree", "child worktree", "cardStatus", "spawn codex/claude in a worktree", "read/wait/send Orca terminal", "terminal send", "full handoff", "handover", "give this to another agent", "another worktree", "Orca browser", or "control the browser inside Orca". Prefer this over raw `git worktree`, ad hoc PTYs, Playwright, or Computer Use when the task touches Orca-managed state. Use Computer Use for browser windows, webviews, or desktop UI outside Orca's embedded browser.

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.

Ultimate Mastra Framework development toolkit for agent orchestration, workflow design, and MCP integration. Owns scaffolding and boilerplate generation (create-agent, create-tool, create-workflow with registry wiring), server start/stop/status, Studio lifecycle and reachability, and analyze commands auditing registered agents and tools.

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.

Read-only Jira navigation and analytics via the jira-sandbox MCP server (mcp__jira-sandbox__* tools). Use whenever the user asks about Jira in any form — a ticket key like PROJ-123, sprint or backlog status, standup prep, what's blocked, or metrics like velocity, cycle time, and project health. NEVER calls Jira write tools — when the user asks to change Jira (create, comment, transition, sprint moves), use jira-writer instead.

Deliberate, confirmed writes to Jira via the jira-sandbox MCP server — create issues, comment, update fields, transition status, epics, sprints, story points. Use whenever the user explicitly asks to change Jira ("create a ticket", "comment on PROJ-123", "move it to Done"). Every write gets a preview + explicit confirmation first. For lookups, status questions, or reports use jira-reader — never use this just to read.

Deep research and architecture design for new product development

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.

Mastra Evaluation and Testing guide - built-in scorers, custom scorers, datasets, experiments, and CI integration. Covers createScorer(), built-in scorer factories like createAnswerRelevancyScorer(), runEvals(), dataset management, and experiments that compare models, prompts, or agent variants against the same dataset.

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.

Mastra Deployment and Server guide - server adapters, authentication, middleware, client SDK, cloud providers, and production deployment. Covers registerApiRoute custom endpoints, server middleware, CORS config, MastraClient calls from Next.js/React frontends, auth providers, and cloud/serverless targets (Vercel, Cloudflare, AWS, Azure).

Mastra Memory system guide - storage backends, message history, observational memory, working memory, semantic recall, and thread management. Covers Memory class options (lastMessages, semanticRecall, workingMemory schemas, observationalMemory), resourceId/threadId scoping, listing and resuming a user's threads, and per-user conversation state at scale.

Use Orca orchestration for structured multi-agent coordination: threaded messages, blocking ask/reply flows, task dispatch, worker_done/escalation waits, task DAGs, decision gates, coordinator loops, or decomposing work across agents. Use `orca-cli` instead for full ownership handoffs, including requests phrased as "hand off", "handoff", "handover", "give this to another agent", or "another worktree" when the user did not explicitly ask to supervise, monitor, wait for results, or coordinate a DAG. Use `orca-cli` for ordinary terminal control, lightweight terminal prompts, shell commands, Orca worktree management, reading or waiting on terminals, and automation of the browser embedded inside Orca. Use Computer Use for browser windows, webviews, Orca app UI, or desktop UI outside Orca's embedded browser.

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.

Breadth-shaped work, in-session, one machine: many independent units of the same job, coordinated as code, not agent chatter. Triggers: 'audit every route', 'across every endpoint', 'one agent per file', 'each file', 'sweep the codebase for X', 'fan them out and verify', 'in parallel across every service', 'all routes', 'for each of the packages'. Instructs the Workflow tool: find real data edges, default pipeline(), parallel() only when a stage needs the whole prior set, one JSON-schema contract per node, flatten/dedupe/filter in plain code (never an agent), tier models via Rule 1, verify findings before reporting, isolate with worktrees only when nodes write concurrently. Pick this over fleet-dispatch-and-watch or orchestration when work stays in-session, one machine, zero extra tokens. fleet-dispatch-and-watch: work leaves this machine (tmux+SSH+ worktrees). orchestration: Orca-app-native coordination (ask/reply, worker_done, task DAGs). Compose, don't compete — a node may dispatch to the fleet.

Strategic planning and team orchestration for Mastra development - analyzes tasks, designs team compositions, creates execution plans, and coordinates agent splits. Use for complexity assessment, choosing which specialists a Mastra effort needs, task breakdowns into parallel execution groups/waves with dependencies, and assigning agent roles.

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

Mastra MCP integration guide - MCPClient for consuming tools, MCPServer for exposing agents/workflows, tool creation, and publishing. Covers createTool() with Zod input/output schemas and execute context, MCPClient getTools()/listToolsets(), MCPServer transports (startStdio/startSSE/startHTTP), and reusing external MCP servers instead of rebuilding tools.

Mastra Streaming patterns - agent streams, workflow streams, tool streaming, SSE events, and AI SDK integration for React/Next.js UIs. Covers textStream vs fullStream chunk types (text-delta, tool-call), streaming from inside tools via context.writer, workflow run.stream() progress events, toAISdkStream()/chatRoute()/useChat wiring, and fixing responses that arrive all at once.

Mastra Workflow development guide - DAG composition, control flow, suspend/resume, HITL, time travel, state management, and streaming. Covers createWorkflow()/createStep(), .then/.parallel/.branch/.foreach/.map, dountil/dowhile loops, sleep/sleepUntil, restarting a run from a failed step, and restructuring bottlenecked batch steps into per-item execution.

Mastra Workspace development - filesystem providers, sandbox execution, skills system, search/indexing, and tool configuration. Covers LocalFilesystem/S3 mounts, LocalSandbox and E2BSandbox code execution, BM25/vector/hybrid search via workspace.search()/index(), and restricting agent file tools with WORKSPACE_TOOLS (read/search/write/exec permissions).

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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

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. This is the whole-codebase automated scan; reviewing a specific PR, branch diff, or auth change for security issues is /security-review or the security-auditor agent instead.

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.

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.

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. Also fires on ANY "did X actually happen?" verification ask — did the email/job/migration really run, is a specific version actually live on a dashboard or endpoint, does the tracker (Linear/Jira) reconcile against what git actually shipped. This is verification of CLAIMED work; a

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. Also fires on 'what's left / which tickets remain and in what order', on 'first check the foundation — do we already have X set up?', and on any inventory-what-exists-before-we-build ask, for any project. Decides WHETHER and HOW to enter the execution skills (start-phase-plan, feature-new); run it first.

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.

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. Also fires when a request names a whole platform or several subsystems in one breath, when requirements are admittedly unsettled ('not totally sure how we want it to work'), or when the current session's context is ballooning mid-task and remaining work should be split or offloaded. Not a hard gate — small clear tasks just proceed.

Use mid-flight while executing for Mark to interpret his terse steering grammar. Triggers on short directives — greenlights ('yes', 'go for it'), autonomy grants ('you have full autonomy', 'dont stop', 'run 2-3 goals on your own'), hard overrides ('no remove this', 'not X but Y'), re-anchoring ('remember the goal', 'get back on track', 'this looks wrong our main objectives are'), and method/preserve constraints ('no just cli', 'keep the save button'). Encodes bounded autonomy vs human checkpoints; his corrections are the spec.

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.

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 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.