find-skills
vercel-labs/skillsHelps the agent find and install agent skills from the open ecosystem with the skills CLI.
Most installed first. Copy the install command into a terminal; Claude Code loads the skill when a task needs it.
Helps the agent find and install agent skills from the open ecosystem with the skills CLI.
Interviews you relentlessly about a plan or design while recording decisions in glossary and ADR files.
Scaffolds per-repo config for the engineering skills: issue tracker, triage labels, and domain doc layout.
Compacts the current conversation into a handoff document saved to a temp folder for another agent.
Interviews the user in rounds about a plan, giving a recommended answer to each question until aligned.
Moves issues and external PRs through triage roles, verifies them, and writes agent-ready briefs.
Implements a spec or tickets, runs tdd and code review, then commits to the current branch.
Routes you to the right skill or workflow for your situation, from idea to shipped code.
Maps a too-large effort as decision tickets on the tracker and resolves them until the route is clear.
Splits a plan into vertical tracer-bullet tickets with blocking edges and publishes them to the tracker.
Makes the agent reply in terse, caveman-style prose to cut output tokens while keeping technical facts.
Guides the agent through creating, testing, benchmarking and optimizing other skills with evals.
Compresses a memory file into caveman-style text to cut input tokens, keeping a backup of the original.
Makes the agent clarify what the user really wants and get a design approved before building anything.
Shows a quick reference card for the caveman skills, modes and commands without changing any state.
Guides the agent to hand code search, small edits and diff review to subagents with compressed output.
Prints the recorded token usage of the current Claude Code session without estimating savings.
Coordinates supervised Orca workers and task DAGs, or hands work off to another agent via orca-cli.
Implements a spec's ticket graph with parallel subagents on one integration branch.
Reviews a coding session and suggests environment fixes such as navigation pointers and automated checks.
Makes the agent turn a spec into a detailed, bite-sized implementation plan before touching code.
Makes the agent check for and invoke relevant skills before any response or action.
Makes the agent run fresh verification commands and read their output before claiming work is done.
Has the agent execute an implementation plan task by task in the current session, with one final whole-branch review.
Has the agent run an implementation plan by dispatching a fresh implementer per task, with reviews after each and at the end.
Makes the agent split independent problems across parallel subagents with isolated, hand-built context.
Makes the agent write, test and refine skills using a test-driven, RED-GREEN-REFACTOR style process.
Read-only repo explorer that locates relevant code and returns path and line citations only.
Makes the agent solve each coding task with the smallest complete change and a brief, clear reply.
Applies caveman learn findings as consent-gated edits that cut agent token cost, measured per change.
Inspects and controls Herdr panes, tabs, and workspaces, but only when the user explicitly asks for Herdr.
Makes the agent write a structured spec with objectives and scope before coding, reviewed in gated phases.
Splits a spec into small ordered tasks with acceptance criteria and a dependency map.
Curates the context an agent sees: rules files, specs, source, and errors, loaded at the right time.
Reads current or past session transcripts and builds an evidence-cited report on what went wrong in a superpowers session.
Guides the coding agent to state assumptions, keep changes minimal and define verifiable success criteria.
After substantive answers, appends two or three follow-up questions to help the user check facts and assumptions.
Switches replies to terse caveman style, cutting about 75% of tokens while keeping technical accuracy.
Shows ponytail's published benchmark savings in code, cost, and speed, without changing any state.
Shows a quick reference of ponytail levels, skills, and commands without changing any state.
Runs CEO, design, engineering and DX reviews of a plan in sequence with automatic decisions.
Coordinates a crew of coding agents from one controller that merges work in trains and relays approvals.
Warns before running destructive shell commands such as recursive deletes or dropping database tables.
Reloads context saved by context-save so the agent can resume earlier work where it stopped.
Saves the current working state, decisions and next steps so a later session can pick them up.
Routes a request to the right gstack skill in the suite.
Makes the agent cross-examine non-trivial decisions with a fresh-context adversarial review before proceeding.
Interviews the user one question at a time to pin down their real intent before any plan or code.
Scaffolds an agent company package that conforms to the agentcompanies/v1 spec, from scratch or from a repo.
Creates and kicks off a Paperclip case from a user request, with workflow instructions and an initial agent.
Turns a tweet, task, or idea into a reviewed skill in the Paperclip skills catalog, reusing prior art first.
Generates a project-local skill that drives the app like a user and captures evidence it works.
Runs Paperclip heartbeat tasks: reads task context, delivers documents, reports blockers and delegates work.
Manages a Paperclip AI-agent company via chat: onboarding, agents, approvals, task monitoring and costs.
Decides whether plan steps need separate tasks and sets real blocking dependencies between them.
Creates Paperclip agents under hiring permission rules, comparing adapter configs and drafting a hire request.
Stores and retrieves durable facts, daily notes and entity records across sessions in a PARA file layout.
Builds a Claude Code cost report from local transcripts, estimated at list prices, as HTML and JSON.
Chains make-plan, do and babysit skills to carry a coding task through without manual step-by-step prompts.
Searches past claude-mem memory in layers, from index to full details, before reading raw tool logs.
Saves a multi-agent DAG definition under a name so it can be re-run later without pasting it again.
Runs five adversarial agents to critique a plan, then turns the surviving insights into an executable plan.
Shapes replies for an ADHD reader: next action first, numbered steps, restated state, and visible progress.
Runs hypothesis-tree optimization loops that track experiments and evidence across repeated evaluator trials.
Creates, updates, or audits CLAUDE.md files so AI agents get concise, accurate project onboarding.
Runs a multi-category quiz on Claude Code skills and returns per-topic scores and a personalized learning path.
Reads a codebase and recommends hooks, subagents, skills, plugins and MCP servers to add, read-only.
Audits CLAUDE.md files against quality templates, reports gaps, then makes targeted updates.
Explains how to write hookify rule files that warn about or block agent actions by pattern.
Guides splitting a feature into parallel work streams with file ownership and interface contracts for multiple agents.
Guides breaking complex tasks into parallel units with dependency graphs, clear task descriptions, and balanced workload.
Sets message-type rules, plan approval, and shutdown steps for communication between agent teammates.
Guides choosing agent team size, preset team setups, and subagent types for a multi-agent task.
Turns a book or document into a structured agent skill with frameworks, principles, techniques and anti-patterns.
Imports Claude Code and Codex session history into one cognee dataset and answers questions across both.
Routes large command and tool output through a sandbox so only the needed results enter context.
Runs diagnostics on the context-mode install: runtimes, hooks, FTS5, plugin registration and versions.
Indexes a local file or folder into a searchable knowledge base so later searches avoid rereading it.
Permanently deletes indexed content and session data, for one session or the whole project.
Searches the indexed knowledge base for focused snippets from local project files and docs.
Shows how much context window context-mode saved this session, with token use per tool.
Pulls the latest context-mode from GitHub, rebuilds it, reinstalls it, and reconfigures its hooks.
Keeps task plans, findings and progress in project files so multi-step agent work survives context loss.
Keeps task_plan.md, findings.md and progress.md on disk to plan and track multi-step agent work.
Keeps task_plan.md, findings.md and progress.md on disk to plan and track multi-step agent work.
Keeps task_plan.md, findings.md and progress.md on disk to plan and track multi-step agent work.
Keeps task_plan.md, findings.md and progress.md on disk to plan and track multi-step agent work.
Keeps task_plan.md, findings.md and progress.md on disk to plan and track multi-step agent work.
Sets up an owner profile for a personal agent and distills source material into person profiles.
Builds several independent candidate solutions to one brief, compares them and synthesizes the strongest.
Writes a session handoff for another agent, or resumes from a chosen continuity source.
Runs a measured loop that attributes a workload's cost or scores variants, keeping only confirmed winners.
Produces a structured plan for multi-step software or non-software work, without implementing it.
Forms a grounded, decisive verdict on an adoption question, document, or set of approaches.
Searches past Claude Code, Codex and Cursor sessions to answer what was tried or decided before.
Scores pre-coding confidence on duplicates, architecture, docs, OSS references and root cause.
Runs project management with PDCA cycles, confidence checks and session context restore.
Switches the agent to terse, abbreviated output to save tokens when context is tight.
Turns a rough idea into a self-contained goal brief with checks an autonomous agent can run.
Reconciles project docs, agent rule files and memory with the code so the next session starts current.
After repeated failures, pushes the agent to exhaust every fix using pressure-style motivational prompts.
After repeated failures, uses performance-review style pressure to make the agent exhaust all options.
After repeated failures, uses Japanese-style corporate pressure to make the agent exhaust every option.
Runs a sleep cycle that mines past sessions and proposes held-out-gated CLAUDE.md and SKILL.md improvements.
Turns a research experiment plan into implemented code, deploys it to GPUs and collects first results.
Teaches compaction and handoff summaries that keep decisions, files, risks and next steps in long sessions.
Diagnoses context failures such as lost-in-middle, poisoning and clash, with a mitigation for each pattern.
Guides context engineering, multi-agent design and evaluation for production agent systems.
Explains context window anatomy, attention mechanics and the U-shaped curve behind context engineering.
Guides context budgeting, observation masking, KV-cache reuse and partitioning to cut token cost.
Offloads tool output and state to files as scratchpads and handoffs, loading context just in time.
Designs harnesses for autonomous agent loops with locked surfaces, durable logs, rollback and approval gates.
Guides sharing orchestrator memory with worker agents through KV cache compaction instead of text summaries.
Designs launch prompts for long-running autonomous or parallel agents, with exact success criteria and stop rules.
Designs persistent agent memory covering entity tracking, temporal validity, graph or vector retrieval, and consolidation.
Guides multi-agent system design: context isolation, supervisor or swarm coordination, handoffs, and when to use them.
Applies a ten-stage reasoning loop to consequential decisions, reviews, and tradeoffs without editing files.
Detects the source type of a URL, repo, PDF or video and builds an AI skill from it with Skill Seekers.
Acts on one AO session or PR: stop, resume, end, merge, review, screenshot, send files, keep host awake.
Finds AO sessions waiting on the user and sends the user's chosen answer back to that session.
Passes the user's request to a project's AO orchestrator, waits for its reply, and relays it back.
Shared rules and connection helper that every ao-* skill follows, covering AO hosts and session naming.
Read-only report of AO sessions across all hosts: running, waiting, idle, exited, and PRs ready to merge.
Lets a worker agent claim tasks and record step progress in a colony SQLite queue.
Makes the agent copy key values from tool results into working notes before context pruning removes them.
Makes the agent classify tool failures and retry, fix, record or escalate each one instead of dropping it.
Makes the agent keep a structured scratchpad of decisions, extracted values and open questions.
Makes the agent periodically check its output for drift, dropped items and contradictions, then adjust.
Guides the agent to split colony work across parallel workers using a tracker table and playbook.
Guides the agent to write new Agent Skills that follow the spec, with the right scope and directory.
Distills reusable lessons from the current session and stages skill-library updates through the proposal tool.
Routes a UI task to the smallest useful set of UI skills through the ui-skills CLI before implementation.
Clones the later half of the current conversation into a new session to save tokens while keeping recent work.
Writes or updates a HANDOFF.md file with goal, progress and next steps so a fresh session can continue.
Clones the last quarter of the current conversation to cut context size while keeping recent work.
Reviews recent conversation history to suggest improvements to CLAUDE.md files.
Guides creating Claude Code skills: trigger rules, hooks, enforcement levels and progressive disclosure.
Reference for choosing Plannotator commands for plan review, code review, annotations, exports and the Inbox.
Analyzes denied plan archives for feedback patterns and writes an HTML report with prompt improvements.
Opens the Plannotator Inbox and teaches the agent to leave the person messages and questions to answer later.
Turns an idea into a /goal package via an interview, a reviewed fact sheet and codebase exploration.
Turns feedback from past harness runs into updates for its agents, skills and orchestrator, with a change log.
Designs a project's agent team and per-agent skills, then writes an orchestrator skill and a CLAUDE.md entry.
Runs an autonomous baton-passing loop that builds site pages with Stitch, one iteration at a time.
Runs agency-orchestrator YAML multi-role workflows inside the current agent session, without an API key.
Guides spec-driven delivery from PRD to epic, GitHub issues and parallel agent work with status tracking.
Tells the orchestrating agent when to delegate work to fresh, ephemeral workers and how to brief them.
Enforces the shared Go contract for how coding agent runtimes invoke advisory code reviewers.
Guides bounded review-driven defect work with receipts, delivery gates and approval checks before implementation.
Runs an autonomous review-and-fix loop on any code target until a named reviewer passes it.
Runs a review-and-fix loop on a Claude Code skill until its review comes back clean.
Guides designing multi-agent workflows with clear boundaries, handoffs and monitoring for PM tasks.
Sets a shared protocol for autonomous research: labeled evidence, search-plan gate, and diffable outputs.
Audits Claude, Codex, or Pi agent config, instructions, hooks, and MCP setup for drift and misconfig.
Turns an article or prompt pack into small, validated reusable agent skills with demos and a narrow commit.
Audits changes, verifies claims with evidence, and explains results in plain grade-5 language.
Installs, updates, removes and deploys agent skills through the skills-manager CLI.
Scores SKILL.md files on a nine-point rubric, then hill-climbs edits with blind judges and git rollback.
Guides the agent to write a durable SDD plan with an execution path before substantial DeepChat changes.
Guides the agent to recall and store durable learning in Memory, Skills, Scheduled Tasks or Tape correctly.
Scores Claude Code agents, skills and commands on 16 weighted criteria and grades production readiness.
Reads the codebase, asks three targeted questions, then recommends an AI-assisted development methodology stack.
Turns a multi-file task into a spec, then runs and verifies it in the background.
Lists, scans and sets default existing repositories used as context for interviews.
Lists and cancels stuck or orphaned Ouroboros executions and background jobs via MCP.
Runs a Socratic interview that turns a vague request into goals, constraints and acceptance criteria.
Prints a reference guide to Ouroboros commands, agents and the workflow loop.
Executes a Seed spec file as a background job and checks each acceptance criterion against the result.
Shows an Ouroboros session's status and, on request, measures its drift from the seed goal.
Runs a background loop that repeats evolve steps until QA passes, converges, or hits its generation limit.
Lists unfinished Ouroboros sessions after a disconnect and shows the commands to reattach to them.
Turns settled goals and constraints into a validated, immutable Seed spec with acceptance criteria.
Walks the user through Ouroboros hands-on, from a rough idea to interview, Seed, run and evaluate.
Brings five lateral-thinking personas to a stuck problem or hard choice and converges on one recommendation.
Shared norms for interviewing users in rounds with ask_user_question: question design, options and fallback.
Routes new project onboarding, PR lifecycle work and behavior changes to the matching workflow skill.
Routes a project to the right spec-setup flow: existing specs, new project interview, or codebase import.
Turns a raw idea in an empty workspace into a goal-and-requirements doc, confirmed section by section.
Keeps a chat-scoped plan of grouped tasks and steps, with loose items queued at the end for later pickup.
Checklist for adding or changing workflow skills in the pi-thinkrail-workflow package against its spec.
Scaffolds VS Code .agent.md custom agent files with tool lists, instructions and handoffs.
Scaffolds new agent SKILL.md files with valid names, frontmatter, sections and directory layout.
Diagnoses skill evaluations that regress or lack power, then suggests targeted fixes to skills or evals.
Extracts reusable patterns from finished sessions and saves them as learned skills via a Stop hook.
Suggests manual context compaction at task boundaries, triggered by a tool-call count hook.
Runs one unattended ideation pass that proposes user-facing improvements as idea issues, without coding.
Runs one unattended QA iteration: updates open QA PRs, then builds one queued test task as a PR.
Finds the most valuable untested behavior and files one qa issue describing the test, without writing code.
Runs one unattended implementation pass: fixes urgent interrupts, or builds one queued idea into a PR.
Routes requests to create or manage Specialist agents and Skills on the Open Science platform.
Routes a multi-step AI-writing task (audit, rewrite, file edit, verify) to the right sub-skill in order.
Has independent perspectives attack a technical proposal, then distills the findings for a separate planner.
Diagnoses a stuck, looping, or drifting agent run and prepares the smallest safe recovery step.
Writes or updates AGENTS.md or CLAUDE.md with only what the code cannot show, and verifies commands.
Summarizes AI agent progress, blockers, quality gates and throughput for a manager's review.
Guides the agent through writing a new SKILL.md, from scoping and frontmatter to structure and installation.
Convenes historical-thinker personas to debate a problem from several angles and reach a verdict.
Generates design options in parallel from several thinking frames, then scores, prunes and deepens the best.
Validates, scores and reviews work using whichever external AI providers are available.
Implements a task by coordinating available external AI providers in the Develop phase.
Researches a topic by dispatching background probes to external AI providers and synthesizing results.
Splits a large change or migration into work packages run in parallel, each with quality gates.
Handles small ad-hoc tasks directly, skipping the full multi-phase workflow.
Sets rules for background agents that write results to files so sub-agent transcripts stay out of the main context.
Tells the agent to hand multi-file implementation work to sub-agents so the main context stays small.
Runs a full software lifecycle autonomously: spec, implementation, tests, debugging, and deployment.
Runs tasks in a governed mode that freezes requirements, bounds execution, and enforces verification.
Makes the agent add a new coding-agent integration to cc-sdd by following its plan-first SOP.
Entry point that picks the right spec path for new work and refines ideas through structured questions.
Implements approved spec tasks with TDD, optionally dispatching a fresh sub-agent per task with review.
Adversarially reviews a finished task against its spec, boundaries and verification evidence before approval.
Generates requirements, design and tasks for every pending roadmap feature, running independent ones in parallel waves.
Writes a technical design for a spec, mapping each requirement to components, interfaces and diagrams.
Initializes a new spec folder with spec.json and a requirements template, clarifying the feature intent first.
Runs init, requirements, design and tasks in one pass, interactively or automatically with --auto.
Generates EARS-format requirements for a spec, with explicit scope boundaries and a pre-write review gate.
Teaches the agent to research real top app screens via the Appllama MCP, then build from them.
Logs task friction and user corrections to a workspace log, then turns them into skill updates.
Sketches types, signatures and module layout before coding, then implements against the sketch.
Runs parallel candidate attempts on one task, picks a base, and grafts the strongest parts together.
Turns the user's working conventions and recent transcripts into a personal -mode skill for agents.
Turns repeated agent mistakes in a repo into architecture, type, lint, or test checks that catch them.
Recommends one next action from task, queue, inbox and health state, without executing it.
Saves workflow friction from your corrections or sessions as methodology notes for later reuse.
Reviews logged observations and tensions to test system assumptions and propose changes.
Audits a CLAUDE.md for vague rules, unnamed files, stale facts and bloat, with rewrite suggestions.
Explains a repo's shared Claude Code setup to a new teammate without changing any files.
Keeps the agent from speculative hardening and scope creep while finishing the requested work fully.
Hardens a plan through Claude and Codex review rounds, then optionally builds and cross-inspects it.
Recommends which model or agent should handle a task, and can run one scoped handoff on request.
Have Codex build a spec-defined work order, then have Claude independently inspect the changes.
Interviews you about a plan, then has Codex review it read-only until approved, before any code.
Interviews you against project docs and glossary, updates them, then has Codex review the plan.
Legacy alias for Loopy: discovers, audits, runs and debriefs repeatable, bounded AI agent loops.
Discovers, audits, crafts, runs and debriefs repeatable AI agent loops, each with bounded terminal states.
Writes stable project agent instructions and tool config from agreed product and technical decisions.
Writes a compact, factual project handoff for another session or tool without transcripts or secrets.
Generates structured .code-task.md files with Given-When-Then criteria from descriptions or PDD plans.
Lists all code task files in the repo with their status, dates and metadata, with optional status filters.
Answers Ralph Orchestrator questions from its published docs before guessing, and scopes code changes.
Creates, validates and explains Ralph hat collection files in .ralph/hats for multi-hat workflows.
Starts, monitors, resumes, merges and debugs Ralph loops using the ralph CLI and loop state files.
Runs Plans.md tasks as a Codex team, as an alias of harness-work with optional Cursor worker delegation.
Sends read-only questions and design reviews to Cursor's agent in ask mode, which cannot write files.
Hands one file edit to Cursor Composer in a separate worktree, then reviews the diff before merging.
Runs a background Codex loop that executes ready task batches via Breezing, with status and stop controls.
Executes Plans.md tasks end to end with Codex-native tools, from one task to a full parallel team run.
Designs an auditable, phased playbook for large or unfamiliar tasks and logs each decision.
Guides setting up hooks and two-tier memory so coding agents learn from past sessions.
Creates and configures agent.yaml, SOUL.md and skill folders for a gitagent agent directory.
Coordinates several Claude Code sessions as a team with shared task lists, messaging and file locks.
Detects a project's type and writes Claude Code settings with lint, typecheck, test and format gates.
Splits large repo-wide changes into independent units and runs parallel agents in isolated worktrees.
Saves task state and key files before context compaction, then restores them afterward.
Guides context and token budget management: when to compact, trim tools, and delegate heavy output.
Helps check session costs, set budget limits, and cap tool calls to control token spend.
Sorts recent mail into reply, waiting, to-do, read-later and ignore groups, leaving drafts unsent.
Builds a one-page brief for a meeting: attendees, last exchanges, open items and related files.
Sends a decision to five advisors who review each other anonymously, then a chairman gives a verdict.
Diagnoses and changes MemSearch memory settings such as providers, summaries, directories and index health.
Searches past session memories via memsearch and returns the few chunks relevant to the current question.
Distills repeated workflows from MemSearch memory into candidate skills, reviewed before any install.
Finds and installs agent skills from the open skills ecosystem when a user asks how to do a task.
Creates, improves and evaluates agent skills from workflows, prompts and SOPs, with release checks.
Guides the agent to split a bloated AGENTS.md or CLAUDE.md into a short root file and linked docs.
Guides the agent to create reusable Claude Code slash command files with clear structure and steps.
Hands a bounded coding task to the Antigravity agy CLI, then reviews its diff before landing it.
Hands a bounded coding task to Aider, then reviews its diff before landing it yourself.
Hands a bounded coding task to a separate Claude Code session, then reviews its diff before landing it.
Hands a bounded coding task to the Cline CLI, then reviews its diff before landing it yourself.
Lets a Codex orchestrator wait on delegate runs in the background through an MCP relay, without polling.
Hands a bounded coding task to the Codex CLI, then reviews its diff before landing it yourself.
Hands a bounded coding task to the Command Code CLI, then reviews its diff before landing it yourself.
Hands a bounded coding task to the GitHub Copilot CLI as a background implementer, then reviews its diff.
Hands a bounded coding task to the Cursor Agent CLI as a background implementer, then reviews its diff.
Maps installed implementer CLIs to task lanes and writes the config only after the user approves.
Offers brief optional learning exercises after architectural work to deepen understanding of design choices.
Drives a task autonomously to a merged PR, with permission to merge once the merge gate passes.
Completes a task autonomously to a ready, unmerged PR, leaving the final merge to the user.
Creates, validates, exports and audits cross-platform agent skills from a described workflow.
Guides designing, auditing, and debugging agent harnesses across providers, covering loops, tools, memory, and evals.
Builds a researched domain skill bundle: flowchart workflow, domain adapter, trap fixture, smoke eval.
Runs a task through planning, parallel evidence gathering, execution, adversarial verification, and an outcome report.
Makes the agent classify a task, define done, gather evidence, act surgically, verify, and report outcome first.
Diagnoses agent failures, then tests prompt or config fixes against a paired screen before installing them.
Runs parallel Claude agents in tmux on git worktrees, coordinating through git and task lock files.
Writes and runs durable JavaScript workflows that coordinate multiple headless Codex agents in staged parallel work.
Registers an existing GitHub issue so the current session resumes when the next comment arrives.
Has the agent register, send, reply to and read messages with other coding agent sessions via the msg CLI.
Recovers the last task's context from the parent session using a sub-agent to protect the main context.
Searches earlier Claude Code or Codex sessions for past work, decisions, or code patterns and summarizes them.
Patterns for unattended Claude Code loops, from simple claude -p pipelines to multi-agent DAG orchestration.
Walks you through choosing and installing ECC skills and rules into user or project Claude Code folders.
Observes sessions through hooks, saves confidence-scored instincts, and evolves them into skills, commands or agents.
Guides the agent in creating, structuring and refining Claude Code skills as SKILL.md files.
Guides the agent in writing Claude Code hooks that run commands or prompts on tool and session events.
Makes the agent write hierarchical, executable project plans with verification criteria for solo work.
Makes the agent create Claude Code slash commands with YAML frontmatter, XML structure and arguments.
Makes the agent create Claude Code subagents with focused prompts, tool limits and Task tool delegation.
Makes the agent set up an autonomous Ralph coding loop with prompts, structure and test backpressure.
Creates or prunes an AGENTS.md file with minimal repo instructions agents cannot discover themselves.
Optimizes AI skill packs for activation, clarity and cross-model reliability using benchmark loops.
Captures user corrections during sessions and reminds you to run /reflect to update CLAUDE.md.
Syncs the .fpf knowledge base with recent git changes, flagging stale evidence and context drift.
Creates a draft task file in .specs/tasks/draft/ that preserves the user's original intent.
Evaluates Claude Code commands, skills and agents with outcome-focused rubrics to guide improvements.
Applies Anthropic's official skill authoring guidance to structure and tighten a complex SKILL.md.
Interviews the user about a plan or design, saving every answer to a brainstorm file as it goes.
Runs a weekly interview that picks one workflow to automate and ships a single verified artifact or repair.
Adds a concise routing entry for a file, folder, or URL into AGENTS.md or the AIOS index.
Prepares a durable, git-native handoff note so another engineer can pick up the work where it stopped.
Guides writing and reviewing Unreal Engine Agent Skills that the in-editor agent loads through unreal-mcp.
Sets a good-enough threshold before searching, then stops at the first option that meets it.
Checks whether a claim has grounding before asserting it, then answers, fetches, or abstains.
Classifies a problem's cause-effect domain first, then picks the matching response approach.
Under uncertainty, the agent starts from its means and affordable loss, then acts for real commitments.
When a constraint looks fixed, the agent reduces it to verified primitives and rebuilds a simple fix.
Saves the active plan, decisions, file pointers and next steps to a snapshot file for resuming later.
Distills the current session into a structured note of decisions, open questions and next steps.
Delegates coding, code review and plan review to the OpenAI Codex CLI in sandboxed modes.
Lets the agent list, inspect and message other active Codex or Claude Code agents via ai-devkit.
Lets the agent start, inspect, message, group, resume and stop running agents via ai-devkit.
Guides implementation against plan and design using TDD and verification before tasks are marked complete.
Searches the team's shared Activeloop memory index and summaries alongside built-in memory.
Designs a multi-agent team's roles, handoffs, memory and policy owners, and visible agents folder layout.
Adds or audits project memory files and opt-in activation rules that make a folder Agentlas-aware.
Guides designing, assembling and packaging a single agent or multi-agent team through its build workflow.
Act as a live meeting sidekick in the terminal: answer questions, flag risks, track decisions.
Send messages between local coding agents such as Claude Code and Codex through a SQLite store.
Runs an implementer and reviewer subagent loop until the review has no high findings and at most three mid.
Works through every open issue one at a time, closing those that need no action and fixing and merging the rest.
Works through every open maintainer-scrap issue one at a time, fixing, merging or closing each.
Writes structured handoff documents so another person or agent can take over a task.
Guides the agent to write a new Claude Code skill with correct frontmatter and progressive disclosure.
Switches replies to an ADHD-friendly style: short, scannable, with the key point first, for the rest of the chat.
Switches replies to a briefing format: a TL;DR, a status checklist, and numbered choices for next steps.
Switches replies to a terse, no-filler style that leads with the answer, for the rest of the chat.
Applies a senior-architect harness to Pi coding work: clarify scope first, test-first changes, and delegation rules.
Sets up evo in a repo by proposing optimization dimensions, building a benchmark and running a first experiment.
Runs the evo optimization loop, with the orchestrator planning rounds and subagents running experiments.
Summarizes an evo run from stored state only, without running benchmarks or experiments.
Protocol evo subagents follow: a structured brief, verifier checks, and required result reporting.
Helps delegate well-defined coding tasks to parallel AI agents with specific prompts and reviews.
Switches the agent to terse caveman-style replies with fewer tokens until the user turns it off.
Runs a light first-principles check before direction-setting choices to curb fallback growth.
Makes the agent write a short goal frame with success evidence and stop condition before starting work.
Keeps multi-step or multi-session tasks checkpointed and resumable, with drift checks and evidence gates.
Pushes the agent to keep working through repeated failures with a structured recovery method instead of giving up.
A compact version of the recovery method: after failures, pause, list attempts, then try new angles.
After repeated failures, makes the agent try more methods, verify results and report evidence.
Runs, diagnoses and iterates on Agent Skill evaluations using the skill-up command line tool.
Audits or rewrites AGENTS.md so it keeps only lasting principles and moves mechanics to their owning docs.
Traces the unstated decisions an AI implementer made into a verdict ledger, without changing any code.
Runs staged experiments from a hypothesis queue to map parameter effects and keep verified best artifacts.
Runs Claude Code as an independent second-agent subagent for opinions or delegated tasks, with model and effort options.
Archives a finished spec and rewrites it from a build plan into a rationale record.
Tests a skill blind against golden input-output cases in fresh subagents, then edits the skill to close the gaps.
Guides creating or revising agent skills, covering trigger descriptions, brevity, and progressive disclosure.
Adds behavioral guardrails that keep coding scope tight, verify fixes, and avoid shallow patches.
Mines past AI coding session histories for repeated workflows and turns them into installable skills.
Builds a weekly rollup of work threads from SpecStory coding histories, marked new, open, or recently closed.
Explores goals, constraints, and alternative approaches, then saves an approved design before planning.
Guides step-by-step coordination of multi-domain specialist tasks, with handoffs and contract checks.
Searches the user's past AI coding sessions to reuse earlier decisions, rules and fixes before editing.
Searches the user's past AI coding sessions with the deja CLI to reuse earlier decisions, rules and fixes.
Has the agent append short work log entries to a daily journal file and run guided reflections.
Saves a user's stated rule or preference as a persistent project learning via the caliber CLI.
Adds a deterministic config-quality scoring check in src/scoring/checks using shared point constants.
Installs Caliber and a pre-commit hook that keeps CLAUDE.md, Cursor and Copilot configs in sync on each commit.
Audits a repo's agent context files, docs and skills against Claude 5 guidance, then applies approved fixes.
Creates a recurring work loop in a file-based knowledge base with a charter, then verifies it with one real run.
Runs any CLI agent in a detached tmux session and waits for its done-signal and result file.
Sets up repo docs, a one-command dev stack, e2e tests and verify loops so agents can build and check changes.
Guides writing, revising and testing AgentDock skills around a portable SKILL.md core.
Reviews a skill's security and frontmatter, then installs, updates or removes it in AgentDock.
Guides the agent through creating or updating AIPex skills with SKILL.md structure and bundled resources.
Guides the agent through implementing the tasks of an OpenSpec change, using the openspec CLI.
Archives a finished OpenSpec change and merges its delta specs into the main specs.
Puts the agent in a think-only mode to explore ideas and requirements without writing code.
Creates an OpenSpec change with proposal, specs, design and tasks in one step, without editing code.
Merges a change's delta specs into the main specs by direct edits, without archiving the change.
Revises an OpenSpec change's planning documents so they stay consistent, without touching code.
Makes the agent interview the user one question at a time about a plan until the design is settled.
Rewrites technical questions in plain words, screens options with six checks, and gives one recommendation.
Reports whether the agent's work is finished, with proof for each claim and a clear verdict.
Turns a request for the user to act into single-line, plain-language steps, then checks the result.
Runs a premortem on a pending decision in a fresh agent and gives a go or no-go verdict.
Picks the next task from the last report, local changes and open PRs, and merges ready PRs.
Has the agent mark each transcript turn as keep, summarize or drop when cutting it to a fixed size.
Guides choosing a paid frontier model for hard tasks, then monitoring the delegated run for decisions.
Turns a successful task into a reusable SkillPack with skills, prompts, start scripts and an optional zip.
Formats replies as short numbered steps ending in one small next action, for low-friction reading.
Has the agent search prior agent sessions and code history with ctx to recover decisions and provenance.
Scores four execution strategies for a phase or fan-out task and recommends one with agent count math.
Finds and loads the project context files relevant to a task, routed by domain at session start.
Creates and amends a SPEC.md project spec, recording goals, invariants and bugs in a fixed format.
Asks a small set of clarifying questions before implementing when a request is underspecified.
Guides building a managed team skills library by mapping work to shelves and browsing before curating.
Converts local prompt folders into standard SKILL.md skills and syncs them into agent skill directories.
Chooses between spec-based and direct planning modes, then follows the matching requirements, design, and task steps.
Guides the agent through reading this repo's architecture, locating the affected layer and choosing verification commands first.
Saves, searches and prunes small project learnings that money skills auto-load in later sessions.
Schedules and runs business tasks like posting, outreach, reporting and health checks without manual steps.
Makes the agent pause for human review every N tasks, working in short autonomous bursts.
Makes the agent systematically inspect files, tools and existing code before acting in an unfamiliar environment.
Runs an autonomous build-and-verify loop from a spec and ends with a signed evidence receipt.
Lets Claude search, read, store and correct Sno memory through four explicit shell commands.
Lets Codex search, read, store and correct Sno memory through four explicit shell commands.
Lets Cursor search, read, store and correct Sno memory through four explicit terminal commands.
Builds a compact choice card so the human decides key modeling trade-offs at real judgment points.
Lets Codex coordinate sub-agents through Agent Relay messaging, handoffs, and shared status signals.
Helps pick among 24 multi-agent swarm patterns, such as fan-out, pipeline, and debate, and how to run them.
Guides writing SKILL.md agent skill packages for Codex, Copilot, and Amp, with frontmatter and layout rules.
Guides agent workflows that run tests, fix failures, and verify features end-to-end before committing.
Guides writing Agent Relay workflows that loop review and fixes until Claude and Codex both sign off.
Writes Relayflows v2 flows in TypeScript or YAML, with steps, verification gates, and check/run/resume.
Runs the Gas Town multi-agent system through gt and bd commands to track work with convoys and agents.
Splits complex work into parallel subtasks, tracked with persistent task dependencies and session todos.
Improves a project's workflow based on observed failures, with checked fixes and local commits.
Coordinates tasks, proofs and reviews across several Codex, Claude or Cursor windows via a local registry.
Guides a multi-phase discussion: review the problem first, then analyze, compare options and recommend.
Splits a complex task into subtasks and recommends skill combinations for quality or fewest installs.
Plans large rewrites or migrations through analysis, task breakdown and tracking docs, then executes them.
Saves an approved UI design correction as a local candidate rule, with an opt-in privacy-minimized share.
Captures a proven workflow from the current session as a reusable Agent Skill for future sessions.
Turns a coding task request into one concise, ordered action plan without editing any files.
Drives multi-session campaigns by splitting work into phases, delegating to sub-agents, and saving state.
Processes pending intake items through research, plan, build and verify, then packages them as a delivery.
Routes requests to find, improve, create, or audit agent skills, and maintains the skill ecosystem.
Generates Claude Code agent and sub-agent files with frontmatter, tool access and execution patterns.
Analyzes, generates and improves CLAUDE.md files to match a project's stack, structure and team size.
Runs a fresh checker verification pass on finished deliverables and fixes any failures before delivery.
Applies always on rules: verify problems before flagging them, batch minor warnings, and make careful find and replace edits.
Routes a task to a staged orchestrator agent running on Claude Fable 5.1 that delegates work and checks results.
Runs a staged, verified workflow on a Haiku worker agent for low cost bulk mechanical tasks.
Makes the agent plan large tasks in stages, verify each stage with checks, and self review before delivering.
Guides a decision through targeted questions, records the call and rationale, and sets a revisit date.
Surfaces what you don't know before work in an unfamiliar domain, teaching key terms and questions first.
Guides spec-driven Claude Code work with context management, subagent dispatch and a post-dev workflow.
Writes or reviews a charter: deliverables, out-of-bounds areas, owner decisions and provable success checks.
Sends a desktop notification for requests, attention needs or milestones, avoiding duplicate completion alerts.
Lets the agent start, prompt, wait on and read other CLI sessions through the Codeman HTTP API.
Copies one of eight open source AI employee folders into a local directory and runs its self tests.
Audits a codebase read-only and writes prioritized plans another agent can execute without context.
Collects, checks, cancels and follows up background agy jobs, and sets up the agy CLI.
Coordinates an ongoing task by delegating work to AGY while the lead keeps decisions, review and delivery.
Scores an agent's own output on correctness, clarity, actionability and conciseness after a run.
Runs claude-smart plugin commands such as show, learn and dashboard in Codex, which has no slash commands.
Launches autonomous agent loops in git worktrees, where nodes spawn child nodes to run subtasks in parallel.
Sets the discipline for a fractal node's persistent memory: topical pages, no history, clean commits.
Guides the agent to read, send and track inter-node radio messages in a disciplined way.
Opens the local project's Storybloq board and summarizes progress, blockers and handovers.
Plans large multi-file builds with Astra and delegates coding to a Flash worker via Codex.
Leads a build with one configured worker and final acceptance, honoring the model you name for delegation.
Shows codex-on-crack run and review status and submits screenshot evidence for visual review.
Recommends a lead and worker setup from your configured models, then lets you decide before work starts.
Sets up codex-on-crack worker models and role files while preserving your lead and existing config.
Generates CLAUDE.md, AGENTS.md and Cursor rule files from a repo's codebase analysis.
Pauses unfinished work at a safe point, writes a continuation checkpoint, and resumes from it when asked.
Turns a completed task or workflow history into a new reusable skill package or a reviewed design plan.
Puts the agent in terse, zero-fluff mode and applies YAGNI and a reuse-first ladder to code changes.
Checks .flow/memory entries against the codebase and decides keep, update, merge, replace, delete or harden.
Turns the current conversation into a spec file written through flowctl, with source tags on inferred content.
Guides one unclear idea through decision-by-decision discovery into a briefing for spec capture.
Shows the spec dependency graph, blocking chains and parallel execution phases using flowctl.
Delegates coding tasks to external agents like Claude Code, Codex, Pi, or OpenCode through the shell.
Looks up daily cross-platform rankings of agent skills to recommend or compare them, without installing.
Audits installed agent skills for duplicates, broad triggers and instruction conflicts, then writes a report.
Provides review dimensions for checking agent definitions on template compliance, size, safety and testing.
Provides the same agent review dimensions for checking agent definitions, used by the builder-reviewer agent.
Guides the agent through a 5-phase process to design, build, validate and refine new agents.
Turns a repo's AGENTS.md and CLAUDE.md rules into a checkable rubric, then validates and calibrates it.
Sets up hcom so AI coding agents in separate terminals can message, watch and spawn each other.
Asks plain-language questions and writes the prd-taskmaster workflow preferences to a config file.
Runs TaskMaster tasks in parallel git worktrees, verifies each, and merges them into one PR.
Turns any goal into a validated PRD and task graph through discovery, then hands off to execution.
Searches and manages Claude's persistent memory stored in a portable .mv2 file in the project.
Runs a multi-agent research workflow: gathers cited claims, has skeptics refute them, writes one report.
Uses parallel agents to discover codebase patterns and draft governance rules for user approval.
Lists approaches tried and abandoned in this repo, with reasons and token cost.
Shows which repo files cost the most context tokens across sessions, with suggested fixes.
Shows a scorecard of which CLAUDE.md rules Claude follows and which it ignores.
Guides writing Claude Code slash commands: frontmatter, arguments, file references and bash.
Guides creating Claude Code plugin hooks for events like PreToolUse and Stop, including prompt-based hooks.
Takes a YouTube, article or PDF link, extracts it, and writes a Ship-Learn-Next action plan.
Explains storing per-project plugin settings and state in .claude/plugin-name.local.md files with YAML frontmatter.
Lays out Claude Code plugin directories, manifest, and component discovery for commands, agents, skills and hooks.
Summarizes the current session into a weekly agent log of dated bullets, marking reusable outputs.
Turns advice, tutorials or transcripts into Ship-Learn-Next cycles with concrete shippable steps.
Drives a GitHub Project board through Build, QA, Review and Done lanes via onboard, run and stop.
Implements a Ready board card test-first in its own git worktree and opens a draft PR for QA.
Collects problems from project sources, verifies each one, and files the findings as board tickets.
Routes a development task to the right lifecycle stage and can run stages as parallel agent teams.
Breaks a Notion spec into an implementation plan and tasks, then logs progress by updating those pages.
Runs a plan file's tasks one at a time, each in an isolated subagent.
Builds or refreshes the Operator project index by running operator-helper and following its setup guide.
Runs the Operator Helper CLI to build or refresh a project index, upgrading and repairing it when needed.
Initializes the Operator Project Brain by running operator-helper and following its setup guide.
Diagnoses and repairs Operator memory load failures using operator-helper memory checks.
Initializes the Operator user partition by running operator-helper and following its setup guide.
Converts a runbook or skill document into a runnable Morph trace DAG and drives it through a full run.
Queries ChatGPT and Gemini APIs for perspectives, then synthesizes a plan with Claude's own analysis.
Lets a Codex host consult Claude Code CLI via a bridge script for reviews and unified-diff proposals.
Lets a Codex host consult Gemini CLI via a bridge script for reviews and unified-diff proposals.
Lints agent config files such as SKILL.md, CLAUDE.md, hooks and MCP configs against 757 rules.
Coordinates a team of researcher agents over several rounds to produce a verified, synthesized research report.
Decides whether a task needs multiple agents and which topology fits, before any agent code is written.
Runs a staged pipeline that distills a skill from raw sources or fuses several skills into one.
Expands a vague task into hidden dimensions, prerequisites and open questions before the agent acts.
Guides building an installable SKILL.md from an idea or source, or by fusing existing skills.
Asks which agent folder to use, then copies the embedded command files into it, reporting overwrites.
Asks which agent folder to use, then copies the embedded agent definitions into it, reporting overwrites.
Launches independent tasks as parallel agents after checking that their write scopes do not collide.
Runs a supplied task in headless AGY (Antigravity) only when named, and returns the run's evidence.
Runs one supplied prompt through headless Claude print mode with scoped permissions and a time limit.
Runs one supplied prompt through headless Codex exec and captures its output, with no retries or batching.
Routes scaffolding, boilerplate and test generation to the Antigravity Gemini CLI for Claude to verify.
Moves Claude Code skills, memory, MCP and permissions to Antigravity CLI, with dry-run and undo.
Makes the agent identify the real expert, hidden failure modes, and key constraint before a non-trivial task.
Runs read-only codebase overviews, health checks, ADR reviews and decision critiques.
Audits what an agent injects into each request and checks necessity, position and prompt-cache impact.
Finds where the user is the manual step for agents and proposes how to automate or remove it.
Sets up a Fable-style workflow in Codex: inspect first, route by cost, verify before claiming done.
Compares manifest dependencies with the Tech Stack section of each CLAUDE.md and reports changes, read-only.
Checks CLAUDE.md files against last week's git history and reports stale paths and removed dependencies.
Checks that @imports and markdown links in CLAUDE.md files resolve to real files, read-only.
Executes an approved dryforge plan in parallel waves, verifies with real checks, and never merges on its own.
Turns a rough idea or spec into a grounded handoff, spec and plan, asking only the user's own decisions.
Starts a cozempic background daemon that watches session size and prunes context before compaction hits.
Prunes the current Claude Code session with cozempic, then opens a new terminal to resume the trimmed session.
Prunes bloat from the current Claude Code session at a chosen level, showing a dry run before applying.
Re-explains the last reply, or pasted text after /bro, in plainer language without changing any facts.
Keeps code changes scoped to the request, moving extra features and refactors into a suggestions list.
Makes the agent check official Anthropic docs before stating facts about Claude Code, the Claude API, or Claude.ai plans.
Runs a moderated debate among several coding agents that converges on one reviewed spec and task list.
Deploys a two-layer parallel agent hierarchy for large refactors, migrations and audits, run by a commander.
Runs parallel sub-agents over large data jobs, then merges results with progress tracking and error recovery.
Interviews you about a business process, then generates a multi-agent team config with roles and handoff rules.
Launches the Cross-Code Organizer dashboard to view and move memories, skills, hooks and configs.
Scaffolds a new SciAgent Skills entry with valid frontmatter, registry update and validation checks.
Simulates a five-role expert board that debates a major decision and reaches a consensus.
Coordinates parallel worker agents through a goal-driven evaluate loop for track execution.
Coordinates estimator, scheduler, document, QA and safety agents under a supervisor with human checkpoints.
Initializes and maintains project memory files such as wiki, logs, TODOs, and session handoff notes.
Has the agent test a risky technical assumption with a small, falsifiable experiment before committing to a plan.
Has the agent map blind spots, landmines and open questions in an unfamiliar area before any coding starts.
Routes agent tasks to the cheapest capable model, reserving premium models for hard reasoning work.
Explains Claude Code plugin, skill, command, agent and hook mechanics for writing or debugging plugins.
Interviews you about a repeated workflow, then drafts and tests a new AI agent skill from it.
Audits and fixes pipeline DOT files for structure, failure paths, spec coverage, and validation errors.
Turns a vague project idea into a design doc with a pipeline configuration section for DOT generation.
Generates and validates a headless build pipeline DOT file from a spec or design doc.
Maps user approvals and artifact state to the next allowed step in VideoStudio production gates.
Compresses natural-language memory files like CLAUDE.md into terse form to cut input tokens.
Delegates code search, edits, and review to terse-output subagents to save context.
Shows a one-time quick reference card for genshijin modes, skills, and default settings.
Ultra-compressed Thai and English output mode that cuts output tokens while keeping technical accuracy.
Shows real session token usage and estimated savings from the Claude Code session log.
Builds consistent Claude Code agent files with the right tools, model, permissions and memory settings.
Builds consistent Claude Code SKILL.md files, checking for overlap with existing skills first.
Puts the agent in a no-code brainstorming mode that challenges assumptions and sharpens ideas before planning.
Saves session takeaways as Obsidian notes and recalls only relevant past notes as long-term memory.
Guides the agent to write or refine durable memory records (engrams) from conversations, documents and decisions.
Gives the agent persistent memory that recalls and stores learned corrections and preferences across sessions.
Extracts durable corrections, conventions and decisions at session end, skipping transient or sensitive details.
Writes RULES.md, the coding standards AI must follow, with dependency versions checked against registries.
Builds a personal profile from the user's own local AI coding session logs, after cost approval.
Turns a GitHub issue into a plan issue with one linked sub-issue per phase, after user approval.
Turns a GitLab issue into a plan issue with one linked child issue per phase, after user approval.
Creates the next artifact of an OpenSpec change, after the user picks which change to continue.
Runs an idea through a planned, built, self-audited, externally audited workflow in Codex.
Coordinates fixed Planner, Developer and Auditor role sessions in Claude Code through native tools or a broker.
After an external audit PASS, runs strict checks and marks the arcgentic round closed in its state file.
Keeps the agent to minimal, requested-only changes, avoiding unrequested abstractions, rewrites and extras.
Keeps the agent to minimal, requested-only changes and blocks unrequested abstractions and rewrites.
Asks a peer running a different agent backend to draft an implementation plan you can critique and merge.
Hands a self-contained task to a peer agent on a chosen backend and tracks it to completion via ask/ack.
Reference for picking the right repowire primitive (ask/ack, notify, broadcast) to coordinate agents.
Runs a short onboarding chat and writes a user profile that sets how the agent works with this user.
Puts the agent in plan-only mode: it writes a markdown implementation plan and changes no code.
Creates, maintains, or migrates functional agent skills from a brief or a legacy skill directory.
Normalizes a user's skill request into a create context for the fskill-creator main skill.
Analyzes a legacy skill directory into a behavior map and function split plan for migration.
Guides writing Claude Code subagent files, covering description triggers, tool selection and prompt structure.
Splits a large corpus across parallel worker agents, reviews with critics, then has a summarizer write the report.
Guides the agent on choosing Haiku, Sonnet or Opus for delegated work based on task complexity.
Lets the agent search the skills.sh catalog at runtime and fetch full SKILL.md content for context injection.
Starts a multi-agent task by sending one email thread that copies the team and has them take turns.
Audits AGENTS.md rules and skill descriptions, reports what to cut or rewrite, and edits only after approval.
Summarizes where you left off in a project from saved chat memory and git into done, open and next.
Builds a code graph and written profile of the project into memory so later sessions start with context.
Lets the main agent delegate bounded review, discovery or implementation to subagents and accept results.
Delegate bounded review or coding tasks to the Antigravity CLI and continue them in one conversation.
Guide a rough idea to an actionable plan by asking one native multiple-choice question at a time.
Guide when to hand work to Codex CLI for second-model review, with sandbox, model, and effort choices.
Defines roles, seats, shared workspace, approval model and handoff format for a team of Grok Bots.
Delegate bounded coding tasks to Devin CLI over ACP, with single-use permissions and resumable sessions.
Delegate bounded tasks to Grok Build over ACP, with background progress checks and follow-up prompts.
Walks any code change through orient, baseline, smallest fix, tests, verification and self-review.
Reads and changes compact-adviser settings for Codex: hint mode, token thresholds, request logging and API key.
Splits vague project requirements into numbered spec folders and a manifest for later /deep-plan planning.
Puts an idea on trial with a prosecutor, defense and 12 juror Claudes, then gives a verdict and flip conditions.
Writes an AGENTS.md that tells coding agents where design system parts live, its rules and what to avoid.
Turns a manual SOP into a gated agent workflow with a topology, typed handoffs and a human approval stop.
Read-only audit of an agent pipeline that checks task splits, data contracts, shared state and retry loops with evidence.
Applies a staged filter before adding code, dependencies or abstractions, starting with whether it is needed at all.
Runs the agentic-sop-kit workflow on a project or the bundled demo, then summarizes the DRAFT report and manifest.
Runs the procoder commit gate and drives its spec, plan and todo chain before the agent calls work finished.
Audits and fixes Lattice docs and templates so they match the current skill inventory.
Upgrades an existing Lattice skill through rewrite, behavior checks, QA and independent verification.
Creates new Lattice atom, molecule or refiner skill files that follow the framework conventions.
Audits a Lattice skill through three review personas and reports practical behavioral gaps with fixes.
Audits a SKILL.md for soft wording and missing enforcement, then rewrites it into firm imperatives.
Asks layered, adaptive questions to test a plan's assumptions, risks and goals until intent is shared.
Shows which memory files are loaded in the session and which exist on disk.
Marks matching memory entries as superseded across memory tiers without deleting them, keeping history.
Creates the Total Recall memory folders, working memory file and schema, skipping any that exist.
Adds durable ^tr IDs to untagged memory list entries so maintenance commands can track them.
Appends a timestamped raw note to today's daily memory log without any write gate.
Creates, tests, improves and packages agent skills through a draft, eval and review loop.
Makes the agent apply repeated mechanical edits through the apply_codemod tool instead of many Edit calls.
Breaks a new feature into 5 to 20 linked tasks inside an existing Piyaz project without changing its status.
Clarifies requirements adaptively before coding, escalating from quick Q&A to deep exploration and a plan.
Installs and sets up the agentctl mod for task scope limits, pre-run refusals and stale test evidence.
Turns a private local skill into a public-ready one by removing paths, credentials, and personal context.
Mines past agent sessions and memories for repeated workflows and drafts candidate new skills.
Audits each iteration's behavior evidence in three tiers using paired adversarial subagent reviews.
Coordinates messages and handoffs between independent local AI sessions through ACC's own store.
Builds a shareable README profiling your AI coding tool usage from local, read-only history.
Creates and audits portable Agent Skills, with validation, routing checks, and keep or cut decisions.
Routes a reproducible defect found during skill use into a tracked Issue and a tested pull request.
Runs a frozen benchmark eval loop to pick the next Skill failure to fix and record results in a PR.
Orchestrates a six-phase ATDD feature workflow, running each phase with a fresh agent.
Configures and diagnoses token-saver compression settings, routing rules and savings statistics.
Splits parallel work into background Codex tasks with chosen models and effort, coordinated by a lead agent.
Picks each subagent's model, effort, and cascade by measured cost per completed task.
Builds and runs an activation test suite to check whether a Claude Code skill triggers as intended.
Guides the agent through an adaptive 12-stage workflow for non-trivial coding tasks, from research to deploy.
Toggles a mode requiring citations, source grounding, and admitting unknowns until the user turns it off.
Keeps project state in durable files so the agent can resume long-running work across sessions.
Reads the feature roadmap, picks the next unplanned phase, brainstorms it and updates the roadmap file.
Lints agent instructions and tool definitions offline for ambiguity, missing stop rules and mixed formats.
Audits Claude Code or Codex settings against the latest official docs and proposes tailored changes.
Delegates coding, review and research jobs to Antigravity agy sub-agents that run in parallel.
Derives evidence-backed guidelines by contrasting successful and failed agent trajectories on the same task.
Groups near-duplicate atomic guidelines into themed cluster pages while keeping the original pages.
Mines your past agent session history for repeated asks and turns them into project slash-command shortcuts.
Makes the agent answer concisely and avoid token-wasting habits to stretch Claude Code usage limits.
Turns open questions into assumption-testing what-if provocations and a mind map, not ready-made answers.
Portable version that turns open questions into assumption-testing what-ifs and a mind map on any assistant.
Checks ALIVE walnut projects against their update rhythm and flags stalled ones on a daily schedule.
Scans the ALIVE inbox folder for unrouted files and suggests which walnut each belongs to.
Runs iterative, human-in-the-loop planning with one question at a time and explicit trade-off checkpoints.
Shows session cost and context use in Claude Code, with commands to audit, pack and trim tokens.
Finds the habitual words a user types that weaken answers, and maps each to the checks it should trigger.
Searches GitHub for agent skills and checks a skill's overlap and risk before you install it.
Previews fixes for broken skill frontmatter, applies them on request, and can prune broken symlinks.
Patterns for splitting UI work across one synthesis agent or specialist agents, with clean handoffs.
Reconstructs the ordered skill steps behind a past commit, date or feature from ax session history.
Governs general tasks: clarify the real goal, verify facts, act within authority, and check results.
Coordinates optional role-based sub-work for planning, review and parallel tasks, with model routing setup.
Challenges a spec with evidence-backed objections across six categories before plan approval.
Scores a team's AI collaboration literacy from repo evidence and questions, then writes a dated report.
Teaches the agent to write complete briefs for subagents and require checkable report files as handoffs.
Explains how to read winnow stubs in tool output and restore hidden blocks with winnow_recall.
Coaches prompt quality in AI coding sessions, scoring and improving prompts and reporting habits locally.
Turns a rough request into a compact verifiable Goal with evidence, boundaries and stop conditions for Codex.
Writes a block in AGENTS.md or CLAUDE.md listing npm packages changed after the model's training cutoff.
Makes the agent check npm package API changes via stalemap before writing or upgrading code that uses them.
Defines how commands call the DeepSeek Harness bridge: subcommands, flags, environment and failure handling.
Shows the agent how to present DeepSeek Harness bridge results verbatim, keeping run IDs and footers.
Runs a staged planning flow of research, interview, external LLM review, and a TDD implementation plan.
Captures errors and decisions from each agent session into a project-local searchable knowledge base.
Shows a snapshot of the AOS agent dashboard with agents, status, tokens and file conflicts.
Nothing matches. Try a shorter word.