Agentic Coding Tools

Draft and stress-test a VISION.md for a repository, then iterate with the author until they approve it. Mines the repo's real decision record — OpenSpec specs and archived change proposals, capability-timeline ADRs, merged PRs, git history — for evidence, drafts the vision as a testable acceptance policy, and stress-tests it with fault-line hypotheticals only the author can answer. Use on /vision, or when asked to write, refine, or stress-test a project vision, a statement of what a project refuses to become, or contribution-acceptance criteria.

Readiness gate for sync-point operations — inspect validation, rework, and active-agent state before merge

Run generator-evaluator testing against live services

One front door for Langfuse — combines the Langfuse Agent Skill (best practices + docs), the Langfuse CLI (full API surface via npx), and the Langfuse MCP server (native prompt-management tool calls). Use when instrumenting an app, querying or modifying Langfuse data (traces, prompts, datasets, scores, sessions, evals), looking up Langfuse documentation, or configuring Langfuse for a new repo. Routes between Skill knowledge / CLI / MCP based on intent.

Review changed code for reuse, quality, and efficiency, then apply low-risk simplifications that preserve behavior exactly. Requires a coverage gate and characterization tests when the surface is unpinned; dual-run verification proves the suite stays green without changing test expectations.

Worktree lifecycle management scripts — setup, teardown, heartbeat, pin, GC, merge

Orchestrate the full plan-review-implement-validate-PR lifecycle with multi-vendor review convergence

OpenBao/Vault credential seeding and management scripts

Comprehensive project health diagnostic — collects signals from CI tools, existing reports, deferred issues, and code markers into a prioritized finding report

Remediate findings from bug-scrub report — auto-fixes, agent-assisted fixes, and quality verification

Single conversational entry point for the supervisor role — intake a request, or run the recurring discovery-to-approval cycle

Delegate small ad-hoc tasks to any configured vendor without OpenSpec ceremony

Structured decision records for session logs and merge logs at phase boundaries

Operate Railway infrastructure: create projects, provision services and databases, manage object storage buckets, deploy code, configure environments and variables, manage domains, troubleshoot failures, check status and metrics, and query Railway docs. Use this skill whenever the user mentions Railway, deployments, services, environments, buckets, object storage, build failures, or infrastructure operations, even if they don't say "Railway" explicitly.

Interact with Obsidian vaults using the Obsidian CLI to read, create, search, and manage notes, tasks, properties, and more. Also supports plugin and theme development with commands to reload plugins, run JavaScript, capture errors, take screenshots, and inspect the DOM. Use when the user asks to interact with their Obsidian vault, manage notes, search vault content, perform vault operations from the command line, or develop and debug Obsidian plugins and themes.

Create OpenSpec proposal with tiered execution (coordinated / local-parallel / sequential)

Decompose a proposal into prioritized OpenSpec change candidates with a dependency DAG. Scaffolds a proposal first if none exists.

Update OpenSpec specs to reflect implementation reality after debugging, testing, and review

Generate throughput and quality reports from coordinator audit data and episodic memory

Check all configured vendors' readiness in one shot

Render the architecture graph as a single self-contained interactive HTML page — foldable structure tree, animated dependency graph, and cross-connection tracing

Safely preview and evolve an existing active roadmap item-by-item without overwriting execution state. Use for adding, editing, splitting, reordering, or superseding roadmap items; use plan-roadmap to create a roadmap.

Architecture flow validation for cross-layer interactions

Archive a completed roadmap workspace to openspec/roadmaps/archive/<date>-<id>/

Merge approved PR, migrate open tasks, archive OpenSpec proposal, and cleanup branches

Identify high-value next features using architecture artifacts, code signals, and active OpenSpec context

Analyze capability-gap failure patterns from episodic memory and generate improvement reports with OpenSpec proposal stubs

Iteratively refine an OpenSpec proposal by identifying and fixing completeness, clarity, feasibility, scope, consistency, testability, parallelizability, and assumptions issues

Run reusable cross-project security review with profile detection, OWASP Dependency-Check, ZAP container scanning, and risk-gated reporting

Refine a system design or plan to be maximally agent-intuitive, agent-ergonomic, and agent-accretive — grounded in simulated agent journeys and real friction evidence, measured in tool calls and tokens, with falsifiable acceptance probes

Open the artifacts relevant to a review (OpenSpec proposal, branch changes, or explicit paths) in VS Code, in a curated read-order, in the right worktree.

Deploy locally, run security scans and behavioral tests, check CI/CD, and verify OpenSpec spec compliance

Execute roadmap items iteratively with policy-aware vendor routing and learning feedback

Generate changelog entries and suggest semantic version bumps from git history

Create gen-eval scenario YAML files interactively

Implement approved OpenSpec proposal with tiered execution (coordinated / local-parallel / sequential)

Dispatch N parallel variant agents to produce competing working skeletons from an approved proposal, score them via cheap validation phases, and capture human pick-and-choose feedback for convergence-aware refinement

Cloud environment bootstrap (setup script + verify hook) and coordinator lifecycle hooks

Configure and verify coordinator access for CLI MCP and Web/Cloud HTTP runtimes

Validation scripts for work packages, parallel zones, and work results

Provision instant temporary Postgres databases via Claimable Postgres by Neon (neon.new) with no login, signup, or credit card. Supports REST API, CLI, and SDK. Use when users ask for a quick Postgres environment, a throwaway DATABASE_URL for prototyping/tests, or "just give me a DB now". Triggers include: "quick postgres", "temporary postgres", "no signup database", "no credit card database", "instant DATABASE_URL", "npx neon-new", "neon.new", "neon.new API", "claimable postgres API".

Analyze codebase for structural tech debt using software design principles from Fowler's Refactoring, the Design Stamina Hypothesis, and the AWS Builders' Library

Ingest raw session transcripts from coding-agent harnesses via vendor-specific adapters, normalize to a common event schema, triage for struggle signals, and write structured findings to episodic memory

Curates the right context for an agent at the right time. Loaded by orchestrator skills (plan-feature, implement-feature, validate-feature) when a worker is about to start a task and needs to decide which rules, specs, source files, errors, and conversation history to surface. Covers the 5-level context hierarchy, named packing strategies, and the most common failure modes (starvation, flooding, stale context, missing examples, implicit knowledge, silent confusion). Tied to this repo's coordinator, work-packages.yaml scope rules, worktree branching, and OPENSPEC_BRANCH_OVERRIDE handoff conventions.

HTTP fallback bridge for coordinator when MCP transport is unavailable

Triage, review, and merge open pull requests from multiple sources (OpenSpec, Jules, Codex, Dependabot, manual)

Independent plan review producing structured findings per review-findings.schema.json

Drive a deployed frontend via Playwright using OpenSpec WHEN/THEN scenarios; emit behavioral_failure findings.

Analyze active OpenSpec proposals and produce a prioritized "what to do next" report

Refresh architecture analysis artifacts (docs/architecture-analysis/) from the codebase

Shared parallel execution infrastructure: DAG scheduling, review dispatch, consensus synthesis, scope checking

Deterministic generate/check producers for documentation, API contracts, decisions, and OpenSpec projections over the ri-06 ProducerResult contract

Durable, versioned identity, producer-result, and manifest records for project-context refresh callers

Drives development with tests — write a failing test before the code that makes it pass. Use when implementing any logic, fixing any bug, or changing any behavior. Use when you need to prove that code works, when a bug report arrives ("the Prove-It Pattern"), or when you're about to modify existing functionality. Trigger phrases: "write a test first", "TDD", "red green refactor", "reproduce the bug with a test", "Prove-It Pattern".

Guides stable API and interface design for REST endpoints, GraphQL schemas, module boundaries, and component contracts. Use when designing new APIs, defining type contracts between modules, establishing boundaries between frontend and backend, or modifying existing public interfaces. Covers Hyrum's Law, contract-first design, the One-Version Rule, REST resource patterns, pagination, PATCH semantics, and idiomatic type-system patterns in both TypeScript (discriminated unions, branded types) and Python (Pydantic discriminated unions, NewType branded types, FastAPI route shapes, frozen dataclasses).

Optimizes application performance with the MEASURE → IDENTIFY → FIX → VERIFY → GUARD workflow. Covers frontend Core Web Vitals (LCP ≤ 2.5s, INP ≤ 200ms, CLS ≤ 0.1), bundle budgets, and React re-render hygiene, PLUS backend latency budgets, Postgres/MySQL EXPLAIN ANALYZE workflows, N+1 query detection, connection-pool sizing, and async profiling with py-spy / cProfile. Use when performance requirements exist, when Core Web Vitals or p95 latency miss thresholds, or when profiling reveals bottlenecks that need fixing.

Manage the lifecycle of removing systems, APIs, features, and dependencies. Use when sunsetting a capability, replacing one implementation with another, consolidating duplicates, killing zombie code, or planning the eventual deprecation of something new at design time. Covers the Churn Rule (owners fund migration cost), the strangler / adapter / feature-flag patterns, the five-question decision matrix, advisory-vs-compulsory deprecation, and how to drive it through an OpenSpec change.

Iteratively refine a feature implementation by identifying and fixing bugs, edge cases, and improvements

Grounds every framework-specific implementation decision in official documentation. Loaded by orchestrator skills (plan-feature, implement-feature, parallel-review-*) when a worker is about to write code that depends on a specific library or framework version. Encodes the DETECT -> FETCH -> IMPLEMENT -> CITE flow, the 4-tier source hierarchy (official docs > official blog/changelog > MDN/web standards > caniuse), stack-detection from dependency files (package.json, pyproject.toml, requirements.txt, go.mod, Cargo.toml, Gemfile), and the mandatory full-URL citation rule. Defers to the vendor-specific authority skills (langfuse, neon-postgres, use-railway, supabase-postgres-best-practices, claimable-postgres) when the code touches their domain.

Guides systematic root-cause debugging with the Stop-the-Line rule and a reproduce → localize → reduce → fix → guard → verify triage checklist. Use when tests fail, builds break, behavior doesn't match expectations, or you encounter any unexpected error. Trigger phrases: "test is failing", "build is broken", "I'm seeing an error", "find the root cause", "git bisect", "regression", "stop the line".