Skip to content

arthrod/conejo-skills

v3.3.0MIT

arthrod's curated skill set, centred on the Conejo coding-philosophy family (conejo, conejo-code, conejo-debug, conejo-frontend, conejo-merge, conejo-legal) plus the obra/superpowers process skills, Pydantic AI, Plate/DOCX, Tauri/better-auth, Rust, and the Pi terminal agent.

adapt

Adapt designs to work across different screen sizes, devices, contexts, or platforms. Implements breakpoints, fluid layouts, and touch targets. Use when the user mentions responsive design, mobile layouts, breakpoints, viewport adaptation, or cross-device compatibility.

adr

Architectural Decision Record (ADR) workflow — extract decisions from conversations/transcripts, then format them as MADR documents with Definition of Done (E.C.A.D.R.). Covers the full extract → write pipeline. Triggers on "what decisions did we make", "write the ADR", "format as MADR", "check ADR quality", "summarize architectural decisions".

advanced-elicitation

Use when you want to improve response quality through meta-cognitive reasoning. Applies 15+ reasoning methods to reconsider and refine initial outputs.

ag-ui-copilotkit

Build agentic UIs using AG-UI protocol with Pydantic AI (Python backend) and CopilotKit (React/Next.js frontend). Use when creating AI-powered applications that need bidirectional agent-UI communication, shared state between frontend and backend, human-in-the-loop workflows, tool-based generative UI, or predictive state updates. Triggers on requests involving CopilotKit hooks (useCoAgent, useCopilotAction, useCoAgentStateRender), pydantic_ai with ag_ui adapters, or building chat interfaces with backend AI agents.

ag-ui-pydantic

Build AI agent UIs using the AG-UI protocol with pydantic-ai (Python backend) and CopilotKit (React frontend). Use when creating agentic chat interfaces, human-in-the-loop workflows, generative UIs with state management, tool-based rendering, shared state between frontend and backend, or predictive state updates. Covers FastAPI integration, state events (StateSnapshotEvent, StateDeltaEvent, CustomEvent), useCoAgent hooks, useCopilotAction for tool rendering, and real-time agent-frontend synchronization.

agent-architecture-analysis

Use when auditing an agent codebase against the 12-Factor Agents methodology, reviewing LLM-powered system architecture, or assessing agentic app compliance. Triggers on "analyze agent architecture", "12-factor audit", "how compliant is this agent", or "evaluate this LLM app". Also applies when comparing frameworks or planning agent improvements. Not for quick checklists — this performs deep per-factor codebase analysis with file-level evidence.

agent-sandbox

Kernel-enforced (landlock) capability-based sandbox for running AI agents and untrusted code via nono — restrict filesystem, block network, inject credentials, take rollback snapshots, audit trails. Use for sandboxing agents, blocking destructive commands, running untrusted code safely.

better-auth

Skill for integrating Better Auth - comprehensive TypeScript authentication framework for Cloudflare D1, Next.js, Nuxt, and 15+ frameworks. Use when adding auth, encountering D1 adapter errors, or implementing OAuth/2FA/RBAC features.

better-auth-best-practices

Best-practices guide for Better Auth's most-used features — email/password authentication (verification, password reset, hashing, policies), organization plugin (multi-tenant orgs, teams, RBAC), and two-factor authentication (twoFactor plugin). Use when implementing any of these features, when stuck on a Better Auth feature decision, or as a one-stop reference for the common-feature trio.

better-auth-explain-error

Explain Better Auth error codes and provide solutions with code examples

better-auth-providers

Display Better Auth available authentication providers and their configuration

better-auth-security

This skill provides guidance for implementing security features that span across Better Auth, including rate limiting, CSRF protection, session security, trusted origins, secret management, OAuth security, IP tracking, and security auditing. These topics are not covered in individual plugin skills.

better-auth-tauri-pitfalls

Debugging guide and platform-specific gotchas for @daveyplate/better-auth-tauri. Use when troubleshooting auth failures in Tauri desktop apps, diagnosing 404 callback errors, fixing macOS cookie/deep-link issues, or debugging the OAuth redirect flow.

better-auth-tauri-setup

Integration guide for @daveyplate/better-auth-tauri - cookie-based auth in Tauri v2 desktop apps via deep links. Use when setting up Better Auth in a Tauri application, configuring social OAuth for desktop, or wiring up deep link authentication flows.

blog-handoff

Use when a research/development session is ending and the work needs to be captured for a blog post writer. Triggers on "handoff", "blog post", "write up the work", "capture for blog", "document what we did". You MUST pass log locations for investigation.

blog-writing

Use when writing a technical blog post from a BLOG_HANDOFF.md document. Triggers on "write the blog", "draft the post", "blog from handoff", "turn this into a blog". REQUIRES a handoff document as input — use blog-handoff skill first if none exists. Produces fun, deep, self-deprecating technical posts.

brainstorming

You MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).

browser-test-agent

Web browser automation & testing for AI agents — agent-browser CLI (Chrome/CDP, fill forms, click, scrape, screenshot, dev-server verification with page-load + console-error + UI-element checks) plus Playwright toolkit for local web apps (debugging UI behavior, browser logs, screenshots). Use when the user asks for web QA, dev-server verification after npm run dev, or any browser automation against a website. For desktop/Electron/Tauri apps, see desktop-test-agent-tauri.

changeset

Write concise package-release changesets for monorepo publishing — one action verb + one impact statement per bullet, imperative voice, user-impact only. Use when creating a .changeset/*.md for a published package.

code-review

AI-powered code review using CodeRabbit. Default code-review skill. Trigger for any explicit review request AND autonomously when the agent thinks a review is needed (code/PR/quality/security).

coderlm

Primary tool for all code navigation and reading in supported languages (Rust, Python, TypeScript, JavaScript, Go, Java, Scala, SQL). Use instead of Read, Grep, and Glob for finding symbols, reading function implementations, tracing callers, discovering tests, and understanding execution paths. Provides tree-sitter-backed indexing that returns exact source code — full function bodies, call sites with line numbers, test locations — without loading entire files into context. Use for: finding functions by name or pattern, reading specific implementations, answering 'what calls X', 'where does this error come from', 'how does X work', tracing from entrypoint to outcome, and any codebase exploration. Use Read only for config files, markdown, and unsupported languages.

computer-use-agents

Build AI agents that interact with computers like humans do - viewing screens, moving cursors, clicking buttons, and typing text. Covers Anthropic's Computer Use, OpenAI's Operator/CUA, and open-source alternatives.

conejo

arthrod's coding philosophy and dispatcher. Universal red-green TDD, acceptance criteria with independent measurers on every task, stacked PRs via gh stack, evidence-before-claims, context-preserving agent dispatch to OTHER-corpus models (pi → crush → codex → grok → cline → octo → subagents; pi-help for scoped models, favor zai/glm-5.3 and minimax/MiniMax-M3; the reviewer is never the author's corpus), CI/CD wait only on the last task, hidden-gems review doctrine, one-by-one PR replies, no batch review. Routes to conejo-code (active coding), conejo-frontend (strict UI), conejo-merge (calm PR/merge), conejo-debug (skeptical investigation, autonomous deep work). Use when starting any coding work or deciding how to approach a task.

conejo-code

Active coding loop — feature stages (brainstorm→plan→interface→tests→implement→improve→review→loop), red-green TDD execution, acceptance criteria with independent measurers on every task, context-preserving agent dispatch to other-corpus models (pi first — scoped models via pi-help, favor zai/glm-5.3 and minimax/MiniMax-M3 — then crush/codex/grok/cline/octo, subagents last), adversarial reviews, stacked PRs via gh stack with CI wait only on the last task, coding standards, bug-fix learning. Owns the canonical testing, agent-dispatch, acceptance-criteria, stacked-PR/CI, and oxlint/oxfmt doctrines. Use when writing or changing code (backend, logic, APIs, libraries, CLIs), or when configuring oxlint or oxfmt.

conejo-debug

Skeptical investigation and autonomous deep work — hunt PRs like crime scenes, interrogate code and CodeRabbit plans, systematic debugging with multi-agent second opinions from OTHER corpora (pi first via pi-help — favor the best Chinese models — then crush/codex/grok/cline/octo, subagents last), strict TDD fixes. Powerful but slow and systematic. Use when fully autonomous, erroring frequently, facing a complicated matter, or when something must be perfect and the user is not around.

conejo-frontend

VERY STRICT frontend gate. Enforces the universal red-green doctrine PLUS the UI superset — agent-browser E2E click-flows (NEVER tRPC to assert UI), 24/7 dev server, test isolation, Astro Framework and Typescript or React + Tailwind v4 + shadcn, mandatory screenshot + browser-console + design-critique loop before "done". Indexes the design/UI reference skills. Use for any web UI work.

conejo-legal

Research a single US doctrinal legal issue with PR-review discipline and produce a source-audited OKF legal_issue bundle (SKOS digest, source/snippet audit, retained sources), with every run ending merged or closed. Use this skill whenever the user says "conejo legal", "rabbit legal review", "interrogate the doctrine", "stress-test the issue", "just research the issue", "ship the digest", "build the bundle", or "write the legal_issue", "research this legal question", or asks for deep legal research, caselaw or statutory research on a single issue, doctrinal synthesis, or a legal-issue taxonomy entry. Uses only free public sources (CourtListener, GovInfo, eCFR, Cornell LII, CRS) — never Lexis, Westlaw, or other paywalled databases. Also use it to review a pull request that carries such a bundle (PR Review Mode): verify the digest against its retained sources, fix findings within the evidence, and merge or close with a close code. Not for code PR review — that's conejo-merge.

conejo-merge

Main PR-comment handler — calm-implement mode (gate each comment individually, group into tasks, test/install/ship, reply with state changes). Hidden-gems doctrine — different review bots have different training corpora, so weird nits get MORE scrutiny, not less; batch review is forbidden. Use for conejo, rabbit review, just implement, ship the comments, interrogate PRs.

deepagents

Deep Agents framework — architectural decisions (when to use Deep Agents vs alternatives, backend strategies, subagent design, middleware approaches) AND code review (bugs, anti-patterns, improvements when reviewing Deep Agents code). Use when working with Deep Agents — designing a new system or reviewing existing code.

desktop-test-agent-tauri

Desktop & Tauri app testing for AI agents — Tauri v2 + WebKitGTK in Docker (AppImage extraction, Gemini Computer Use, virtual display, DOCX export verification) plus Electron app automation (VS Code, Slack, Discord, Figma) via agent-browser skills get electron. Use when testing a Tauri desktop app (Cicero), Electron app, or any non-browser desktop UI. For web browser testing, see browser-test-agent.

diagnosing-superpowers

Use when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.

dispatching-parallel-agents

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

dogfood

Systematically explore and test a web application to find bugs, UX issues, and other problems. Use when asked to "dogfood", "QA", "exploratory test", "find issues", "bug hunt", "test this app/site/platform", or review the quality of a web application. Produces a structured report with full reproduction evidence -- step-by-step screenshots, repro videos, and detailed repro steps for every issue -- so findings can be handed directly to the responsible teams.

dogfood-quirks

Workarounds for agent-browser version 0.26.0 quirks on Linux (sandbox launch failure, broken --timeout, silent stale refs, find-role syntax). Read BEFORE invoking the /dogfood skill or running any agent-browser command. Otherwise: Chrome won't launch, refs will silently click the wrong element, waits will take 30s instead of 3s.

draft-docs

Generate first-draft technical documentation from code analysis

env-dogma

Scorched-earth env/secrets refactor for Vite + Cloudflare Workers + Tauri. Use when consolidating .env sprawl, hardening secrets handling, or auditing env access patterns.

executing-plans

Use when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available

finishing-a-development-branch

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work

hono

Efficiently develop Hono applications using Hono CLI. Supports documentation search, API reference lookup, request testing, and bundle optimization.

i18n-inlang-localization

Everything i18n/localization for apps — inlang projects (setup, plugins, validation), translating app messages (machine translation, missing translations, base locale), and the /translate slash-command workflow. Triggers on inlang, localization, machine translate, missing translations, locale, baseLocale, plugin-json, i18next, next-intl, ICU message format, /translate.

llm-chat-sdks

Build LLM-powered chat apps with the right SDK — Anthropic SDK / Claude API (prompt caching, thinking, tool use, batch, files, citations, memory, model migrations) AND Vercel AI SDK (useChat, streamText, tool calls, UIMessage, ChatStatus, addToolOutput). Use when implementing chat interfaces, tuning Claude features, migrating between Claude model versions, or wiring up streaming with @ai-sdk/react.

major-task

Work heavyweight framework or library tasks with planning-first research, selective deep analysis, and rigorous handoff

marimo

Everything marimo — writing notebooks (cells, script-mode detection, reactivity), preparing them for scheduled batch runs (Pydantic params, CLI args, WandB), generating anywidget components, and checking WASM/Pyodide compatibility. Use for any marimo notebook task.

mcp-builder

Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).

ml-gpu-training

Everything GLiNER NER — training-strategy decisions (hyperparam sweeps, LoRA vs full FT, loss/OOM/NaN debugging, eval, WandB tracking) AND remote-GPU ops (launching/monitoring runs on AMD GPU droplets via DigitalOcean, creating/destroying droplets, validating configs, pushing models to HuggingFace, installing torch + flash attention). Use for any GLiNER training, fine-tuning, or training-ops task.

orchestrating-swarms

Master multi-agent orchestration using Claude Code's TeammateTool and Task system. Use when coordinating multiple agents, running parallel code reviews, creating pipeline workflows with dependencies, building self-organizing task queues, or any task benefiting from divide-and-conquer patterns.

pi-extending

Building & extending Pi — authoring TypeScript extensions (ExtensionAPI, registerTool, registerProvider, /commands, UI hooks), publishing as npm/git packages (pi-package), embedding via JSON-RPC mode (--mode rpc/json, JSONL framing, AgentSession SDK), and developing inside the pi_agent_rust repo. Use for any "how do I build a Pi extension/package/SDK client" question.

pi-using

Using the Pi terminal agent — workspace setup, sessions, /commands, compaction, settings.json/AGENTS.md, skill discovery, providers/models, plus theme/keybinding/prompt customization (SYSTEM.md, APPEND_SYSTEM.md, settings.json, keybindings.json). Use for any "how do I configure/run Pi" question.

pydantic-acp

Use pydantic-acp to drive an external ACP CLI agent (crush-acp, cline --acp) as a pydantic-ai model backend — create_acp_model, AcpProvider, delegate host clients (filesystem/terminal/permissions), PromptedOutput structured output, and the classic hang/leak gotchas. Use when wrapping cline/crush/any ACP agent in a pydantic_ai.Agent, when acp logs "Error parsing JSON-RPC message" / "Expecting value: line 1 column 1", when an ACP-backed run hangs until its timeout, or when implementing an acp.interfaces.Client delegate.

pydantic-ai-agent-builder

Expert guidance for building AI agents with Pydantic AI framework. Use when creating multi-agent systems, AI orchestration workflows, or structured LLM applications with type safety and validation.

pydantic-ai-common-pitfalls

Avoid common mistakes and debug issues in PydanticAI agents. Use when encountering errors, unexpected behavior, or when reviewing agent implementations.

pydantic-ai-testing

Test PydanticAI agents using TestModel, FunctionModel, VCR cassettes, and inline snapshots. Use when writing unit tests, mocking LLM responses, or recording API interactions.

pydanticai-docs

Use this skill whenever the user is working with the Pydantic AI framework — including building AI agents, defining structured outputs with Pydantic models, wiring up tools/function calling, configuring model providers (OpenAI, Anthropic, Gemini, etc.), managing dependencies via agent context, handling streaming responses, or debugging agent runs. Trigger this skill even for adjacent tasks like "how do I make my agent return JSON", "set up a multi-step agent", "add a tool to my agent", or "validate LLM output with Pydantic" — any time Pydantic AI is mentioned or implied as the target framework.

python-code-review

Reviews Python code AND pytest test code — type safety, async patterns, error handling, common mistakes, plus pytest setup correctness (test file location, conftest.py wiring, asyncio_mode), fixtures, parametrize, mocking. Use when reviewing .py or test_*.py files. Triggers on python code review, pytest review, type hint review, async review, fixture review.

ralph-prd-generator

Generates Product Requirements Documents (PRDs) and specifications for Ralph for Claude Code autonomous development. Use when users want to create a PRD, write specifications, plan a new project for Ralph, convert ideas into Ralph-compatible format (PROMPT.md, @fix_plan.md, specs/), or prepare requirements for autonomous AI development loops.

react

React patterns with destructured props, compiler optimization, Effects, and Tailwind v4 syntax. ALWAYS use when using React.

react-best-practices

Use when reading or writing React components (.tsx, .jsx files with React imports).

react-composables

React component architecture for creating composable, accessible components with data attributes. Use when creating/updating composable components, not for higher-level feature/page components.

receiving-code-review

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation

requesting-code-review

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

review-llm-artifacts

Detects common LLM coding agent artifacts by spawning 4 parallel subagents

review-plan

Review implementation plans for parallelization, TDD, types, libraries, and security before execution

review-python

Comprehensive Python/FastAPI backend code review with optional parallel agents

review-rust

Comprehensive Rust code review with optional parallel agents

rust-author

Authoring & setting up Rust projects — idiomatic Rust (ownership/borrowing/cloning patterns, Result error handling, clippy config, static vs dynamic dispatch, performance, doc tests) plus project scaffolding (Cargo.toml, multi-crate workspaces, CI pipelines, rustfmt). Use when writing Rust code or starting/restructuring a Rust project.

rust-review

Comprehensive Rust code review across four lenses — source code (ownership, borrowing, lifetimes, errors, trait design, unsafe, common mistakes), tests (unit, integration, async testing, mocking, property-based), tokio async (task management, sync primitives, channels), and FFI (extern blocks,

sqlalchemy-code-review

Reviews SQLAlchemy code for session management, relationships, N+1 queries, and migration patterns. Use when reviewing SQLAlchemy 2.0 code, checking session lifecycle, relationship() usage, or Alembic migrations.

sqlite-vec

sqlite-vec extension for vector similarity search in SQLite. Use when storing embeddings, performing KNN queries, or building semantic search features. Triggers on sqlite-vec, vec0, MATCH, vec_distance, partition key, float[N], int8[N], bit[N], serialize_float32, serialize_int8, vec_f32, vec_int8, vec_bit, vec_normalize, vec_quantize_binary, distance_metric, metadata columns, auxiliary columns.

subagent-driven-development

Use when executing implementation plans with independent tasks in the current session

systematic-debugging

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

tailwind-v4

Tailwind CSS v4 with CSS-first configuration and design tokens. Use when setting up Tailwind v4, defining theme variables, using OKLCH colors, or configuring dark mode. Triggers on @theme, @tailwindcss/vite, oklch, CSS variables, --color-, tailwind v4.

test-driven-development

Use when implementing any feature or bugfix, before writing implementation code

testing-review

Review whole-repo test quality, rerun coverage, score remaining worth-testing files, inspect slow-drift and stale test debt, and publish the next testing batch. Use every few weeks or before large breaking changes and rearchitecture.

testing-strategy

Enforces dependency isolation, coverage, and test quality standards for Python pytest suites. Use when writing tests, fixing test failures, increasing coverage, or reviewing test quality. Triggers on: write tests, fix tests, increase coverage, test failures, mock strategy.

using-git-worktrees

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback

using-superpowers

Use when starting any conversation - establishes how to find and use skills, requiring skill invocation before ANY response including clarifying questions

val-town

Use when building, editing, or deploying code on Val Town - the serverless Deno platform. Triggers on val.town, vals, vt CLI, std/sqlite, std/openai, std/blob, esm.town imports, .http.tsx/.cron.tsx/.email.tsx file naming, deno.json with valtown.d.ts types, or HTTP/cron/email triggers needing free OpenAI, SQLite, blob storage, or scheduled execution.

verification-before-completion

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always

writing-plans

Use when you have a spec or requirements for a multi-step task, before touching code

writing-skills

Use when creating new skills, editing existing skills, or verifying skills work before deployment