skills

Create one verified Linear issue from a Codex Agent Task v1 contract and optionally dispatch it under separate explicit authority. Use when a user asks Codex to create a Linear implementation issue for a repository handled by a mapped Symphony workflow.

Use when designing agent tool schemas, action spaces, or observation formatting, or when diagnosing looping and low completion rates in an agent harness.

Use when an agent is looping, retrying without progress, drifting from its goal, or failing repeatedly — structured capture, diagnosis, contained recovery, and introspection reports.

Use when orchestrating agent workflows — eval-first execution, task decomposition, and cost-aware model routing decisions.

Eval-first AI/ML engineering — RAG decisions, finetune-vs-RAG-vs-prompt framework, prompt-injection defense, structured output, model routing/cost, production drift. Use when working on evals, prompts, RAG, or model optimization.

Use when designing or reviewing an HTTP/RPC API surface — resource modeling, pagination, error envelopes, versioning, idempotency. Falsifiable contracts, not style preferences.

Use when building on the Anthropic Claude API or SDKs — model choice, the tool-use loop, token and context budgeting, prompt caching, batches. Falsifiable patterns for production agents, not SDK hello-worlds.

Use when deciding whether/when to compact the session, or when auditing what is consuming the context window (agents, skills, MCP servers, rules). Compaction timing + token-budget audit in one place.

Use when designing schemas, adding indexes, writing migrations, or scoping multi-tenant data — constraint-first modeling and expand/contract migration rules.

Use when work crosses process boundaries — queues, webhooks, background jobs, retries, multi-service writes. Idempotency, delivery semantics, and failure design rules.

FastAPI service-layer architecture, dependency injection, domain-error handling, SQLAlchemy 2.0 async, and Alembic conventions. Use when building or modifying FastAPI apps, in addition to python-patterns.

Use when choosing a branching strategy, hunting a regression with git bisect, running multi-worktree development, or configuring CODEOWNERS and merge queues — falsifiable conventions, not a git tutorial.

Use for GitHub repo operations via the gh CLI — issue triage, PR and CI management, releases, Dependabot — plus CODEOWNERS, reusable workflows, and monorepo path filtering. For operational tasks beyond plain git.

Use when writing or reviewing Go concurrency, context handling, module boundaries, or reliability code — errgroup, worker pools, goroutine-leak avoidance, retry and circuit-breaking. Falsifiable rules, not idiom lists.

Use when writing or reviewing Go tests — table-driven suites, golden files, fuzzing, benchmarks, race-exposing tests, testcontainers integration, or t.Parallel hazards. Falsifiable rules, not a tour of the testing package.

Use when production is broken or degraded — mitigation-first response, timeline capture, severity ladder, and blameless postmortems. Agent-loop failures go to agent-introspection-debugging instead.

Use when building or debugging an MCP server — tool/resource/prompt registration, tool-description engineering, the isError contract, authz and path sandboxing, stdio vs Streamable HTTP. Node/TypeScript SDK; defer to Context7 for current signatures.

Use when adding logging, metrics, tracing, alerts, or SLOs to a service — structured-log contracts, RED metrics, trace propagation, symptom-based alerting.

Forces the laziest solution that actually works, simplest, shortest, most minimal. Channels a senior dev who has seen everything: question whether the task needs to exist at all (YAGNI), reach for the standard library before custom code, native platform features before dependencies, one line before fifty. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "ponytail", "be lazy", "lazy mode", "simplest solution", "minimal solution", "yagni", "do less", or "shortest path", and whenever they complain about over-engineering, bloat, boilerplate, or unnecessary dependencies.

Python style, typing, side-effect, error-handling, async, and tooling conventions (ruff, uv, pytest, pydantic-settings). Use when writing or reviewing Python code.

React Native platform, Metro-port and emulator/simulator worktree isolation, and cleanup conventions (expo-dev-client, adb, avdmanager, simctl). Use when working on React Native apps.

Decision framework for choosing between regex and LLM when parsing structured text — start with regex, add LLM only for low-confidence edge cases.

Research-before-coding workflow. Search for existing tools, libraries, and patterns before writing custom code. Invokes the researcher agent.

Use when designing anything with a trust boundary — auth systems, secrets handling, service-to-service calls, user input surfaces. Design-time security; review-time checks live in the core doctrine.

Evidence-first repo execution workflow. Use when the user wants a command run, a repo checked, a CI failure debugged, or a narrow fix pushed with exact proof of what was executed and verified.

TypeScript/Node conventions — strict compiler settings, parse-don't-cast boundaries, Result-style domain errors, floating-promise hygiene, ESM. Use when writing or reviewing TypeScript.

Two-loop UI/UX discipline — a cold-context grader scores renders against an 8-dimension rubric with binary preservation and audit gates while the implementer iterates from critique briefs; the `impeccable` skill is a hard precondition. Use when asked to improve UX, flow, layout, register, or polish on a page or component.

Use on demand before opening a PR when the local codegraph CLI is installed — pulls the call-graph slice touched by the diff, then dispatches the strict reviewer with that context loaded.

Delegate coding tasks to Codex CLI (GPT-5.4) with a structured plan handoff. Use after planning is complete and the Codex CLI plugin is installed — pass the plan directly to Codex for implementation.

Use when creating or editing hookify rule files (ECC plugin format) that intercept bash commands, file edits, or prompt events — rule syntax, patterns, and configuration guidance.