All official AI rules/Coding

Coding

Improve a Mutation-Testing Tool Based on Its Current Code and Tests

Use when changing a mutation-testing tool. It checks current code and tests first, keeps processing order and lazy evaluation intact, adds mutators that create no broken mutants, writes tests that catch mutants, and follows safe review, CI, and release steps.

Add Features to a Layered Desktop App and Test Every Build

Use when an AI changes a desktop app split into a core, a desktop host, and a web UI. It keeps rules in the core, limits which commands and folders tools may touch, splits optional features by real dependencies, and tests every supported build before calling the work done.

Find Real Bugs in Low-Level Systems Patches Without Style Nitpicks

Use when reviewing patches to low-level systems code such as drivers or packet libraries. It traces memory, locks, and error paths, checks integer sizes, threading, crypto, and API changes, and reports fixable issues, raising style points only when very sure.

Add Features to an Extensible Go Service With Tests That Survive Config Overrides

Use when changing a Go service that downstream builds rename or customize. It keeps trace context in logs, registers new tools in the right group, tests public behavior under config overrides, and updates generated docs.

Build a Compatibility Layer That Copies Another Web Framework's Behavior

Use when reimplementing another web framework's behavior across several runtimes. The AI ports the copied framework's tests first, keeps request order and runtime boundaries, normalizes file paths, and merges only via pull requests that pass every check.

Change a Managed Wrapper and Its Native Library Without Breaking the ABI

Use when editing a cross-platform managed wrapper around a native C library. It traces each change through every layer, builds native binaries from source instead of using stale downloads, keeps the public ABI stable, handles pointer ownership and threads, and never skips failing tests.

Add and Test Kernels in a JIT-Compiled GPU Kernel Library

Use when an AI works on a GPU kernel library that compiles kernels on first use (JIT). It adds kernels through every layer, writes generated files only to writable folders, tests by GPU type, and checks results before measuring speed.

Change and Review a Multi-Protocol Integration Gateway Without Breaking Access Checks

Use when an AI changes or reviews a gateway that links several protocols. It runs the project's checks, keeps access checks strict, keeps log and audit writes apart, builds migrations carefully, and asks before pushing.

Build Async Rust Services That Survive Cancellation and Failure

For async Rust service work: the AI finishes real code without mocks, handles errors and cancellation safely, tests through the live service interface, and passes all checks before calling it done.

Change a Multi-Language Data Library Without Breaking Its File Formats or APIs

Use when an AI changes a fast data library with a native core and thin language bindings. It keeps stable file formats and public APIs compatible, uses the documented commands, and adds tests and docs.

Build Data Replication (ETL) Code Without Silent Value Changes or Data Leaks

Use when building or changing code that copies data between databases. It keeps changes small, catches rounding and other silent value changes, returns errors instead of crashing on bad input, keeps secrets and row values out of logs, and checks tests really ran.

Change a Device Automation Tool and Check It on Real Devices

Use when an AI changes a device automation tool that runs on several platforms. It keeps changes small, keeps command info in one registry, picks tests that fit the change, and checks behavior on real devices or simulators with fresh builds before reporting.

Edit a Large Typed Monorepo Without Breaking Other Packages

Use when an AI edits a codebase with many packages. It finds the package that owns the change, reuses shared utilities, follows build and type rules, tests only the affected packages, and reports only the checks that actually ran.

Change a Database Storage Engine Without Breaking Speed or Compatibility

Use when an AI edits a database storage engine. It keeps error handling and concurrency correct, speeds up frequently run code only with benchmark proof, keeps APIs, file formats, and builds compatible, and requires repeatable tests before approving a change.

Develop a Cross-Platform CLI in a Shared Worktree Without Touching Others' Work

For building a command-line tool in a worktree that other sessions share. It stays inside the current worktree, keeps others' changes, separates data output from messages for people, tests on every OS, and keeps snapshots and docs current.

Build a Rootless Container Tool with Container Locks and Verified Image Downloads

Use when building a container tool that runs without root. The AI locks containers during changes, checks every downloaded image layer, keeps host settings out of containers, stops whole process trees, and rejects unsafe paths when restoring backups.

Build an AI Code Review-and-Fix Tool Without Losing User Code

Use when an AI works on a tool that runs AI code reviews and fixes in the background. It reads the build and owner docs first, blocks commands from untrusted branches, protects running jobs, and stops unsafe pushes or releases.

Write AI Agent Skills and Test That They Actually Improve Results

Use when adding or updating skills in an AI agent skill library. Covers names and versions, descriptions that trigger at the right time, minimal tool permissions, tests with and without the skill, and pre-release checks.

Contribute Small, Tested Changes to a Framework Monorepo

Use when an AI edits code in a framework's monorepo. It finds the main guideline files first, keeps each change to one behavior, writes a failing test before the fix, and checks security, the build, and release notes for the parts it touched.

Change a Large Python Workflow Monorepo Without Breaking It

Use when an AI edits a big Python monorepo that schedules and runs workflows. It keeps the scheduler, workers, and database in their own roles, puts dependencies in the right package, tests the changed behavior first, and reviews the full diff before a pull request.

Change a Client Library's Sync and Async Code Together Without Breaking Its API

Use when an AI changes a mature client library that has matching sync and async clients. It keeps public APIs and errors unchanged, applies the same change to both sides, keeps hot paths fast, and tests from one failing case up to the full test matrix.

Build a Memory Service for AI Agents Without Mixing Memories Between Users

Use when building or extending a long-term memory service for AI agents. Keeps each memory bank separate, splits storing, searching, and reasoning, and covers database migrations, API client updates, tests judged by a second model, and per-tenant or per-bank settings.

Change a Distributed Job Platform Monorepo and Test It With Real Services

Use when an AI changes a monorepo that runs distributed background jobs. It picks the right check for each package, tests with real databases and queues, writes release records, runs the whole local task flow, and reports what was checked and what was skipped.

Build Domain-Driven (DDD) .NET Modules Without Breaking Layers or Public APIs

Use when an AI changes a modular .NET app built with domain-driven design. It follows existing patterns, keeps layer dependencies one-way, puts aggregates, repositories, and DTOs in the right layers, and tests on every supported database without breaking current users.

Change a Multi-Browser Extension Without Leaking Secrets or Breaking Saved Data

Use when changing an extension built for several browsers. Keeps secrets local, regenerates dependency safety policies, adds numbered upgrades for saved data, tests at the right level, and runs Git steps only when asked.

Edit Distributed Machine Learning Training and Inference Code Without Breaking It

Use when changing software that trains or runs machine learning models across many processes or accelerators. It asks before risky changes, keeps model weight versions matched, keeps collective calls in the same order on every rank, protects config compatibility, and reports skipped tests.

Develop a Web App That Streams Live Container Logs and Metrics

Use when changing a backend-plus-frontend app that streams live container logs and metrics. Keeps the layers, stream limits, and login and deployment modes intact, adds features through every layer, runs the documented tests, and writes short reviews.

Change a Public Server Package That Others Extend Without Breaking Them

Use when changing a publicly released server package that others extend through hooks. It keeps secrets out, keeps callbacks, hooks, and middleware order working, adds new migrations instead of editing old ones, and runs the package's real tests and lint.

Patch a Long-Lived Portable C Project Without Breaking Compatibility

Use when an AI changes a mature C codebase that must keep building on old compilers, many platforms, and optional feature sets. It builds and tests the affected setup, follows the style, memory, commit, docs, and release rules, and keeps each patch small and valid on its own.

Edit a Multi-Module Backend and Frontend Repo Without Breaking the Build

Use when an AI edits a repo where the API, backend, and frontend live together. It reads each module's rules, keeps both sides in sync, regenerates the API client instead of hand-editing it, runs tests that fit the change, and asks before migrations or new dependencies.

Change a Large Multi-Language Data Platform Monorepo and Prepare Pull Requests

Use when an AI edits a large data platform codebase written in several languages. It picks the right Git branch, leaves generated files to their tools, uses the smallest test base, tests only what changed, checks every failed CI job, and asks before pushing or opening pull requests.

Build and Review Ansible Infrastructure Automation Without Weakening Security

Use when an AI writes or changes infrastructure automation such as Ansible playbooks. It passes every lint and security check with no warnings, keeps secrets out of the repository, debugs networks from the bottom layer up, proves tests catch the bug, and reports only checks it ran.

Change a Large Python Data System Without Breaking Lazy Execution

Use when an AI changes a large Python data or parallel-computing codebase. It maps the layers first, never runs computation while building graphs, tests from the nearest test outward, and never releases or publishes packages without permission.

Write the Spec First, Then Build in Small Test-First Steps

Use when an AI codes from vague requests in a repo with specs and plans. It logs open questions and waits for answers, updates the spec and plan, writes failing tests first, runs checks for changed files, protects the database, and leaves a clear handoff.

Build Accessibility Checker Rules That Return Pass, Fail, or Incomplete

Use when an AI adds or changes rules in a web accessibility checking engine. It keeps DOM and dependency layers apart, reads HTML and ARIA data from one place, tests with real-looking pages including Shadow DOM, keeps translations in sync, and avoids breaking changes.

Generate Command Schemas for AI Agents from the Real Commands and Flags

Use when building schemas that tell AI agents which commands exist and how to call them. It generates them one way from a reviewed command list and the real commands, and checks coverage, examples, and safety and confirmation info.

Make Small, Compatible Changes in a Java Project Split Into Modules

Use when an AI changes a Java project split into modules. It reads the build and CI rules first, keeps older Java versions and module dependencies working, tests at the right level, and asks before wide or risky changes.

Add Features to a Multi-Language Infrastructure-as-Code Library Without Breaking Existing Users

Use when changing a typed infrastructure-as-code library with generated bindings for other languages. Puts features in the right layer, avoids binding-unsafe syntax, guards behavior changes with feature flags, keeps permissions narrow, and adds docs and tests.

Add Modules to a Go Server Without Weakening Security

Use when building or reviewing features for an extensible Go server. The AI writes each module in order from creation to cleanup, reads config files strictly, passes tests, lint, and builds on Linux, macOS, and Windows before merging, and leaves pull requests to a human.

Build a TypeScript App for Native and Web, Following the Repo's Rules

Use when working on a TypeScript app that runs on native and web. The AI follows the repo's scripts and folder layout, reuses shared components, marks on-screen text for translation, and tests every affected platform before finishing.

Change a Full-Stack Repo from Database to UI Without Breaking Compatibility

Use when an AI edits a full-stack repository. It reads the repo's guidance first, keeps database keys, migrations, and API fields compatible, reuses shared UI components and translation files, and reports only the checks it actually ran.

Fix Failing E2E Tests by Watching the Real Browser

Use it when an end-to-end test fails. It defines the visible success condition, runs the test in a real browser, collects screenshots and console logs, sorts the cause into test, code, or environment, makes the smallest fix, and reruns until it passes or must stop.

Build a Coding-Agent Service That Takes Requests from Chat and Issue Trackers

For building a service whose coding agents take work from code hosts, issue trackers, and chat. Splits the main, reviewer, and analyzer roles, keeps one sandbox per thread, fixes the middleware order, and adds on-off switches for automatic CI repair.

Update a Go API and React SPA by Editing the OpenAPI Spec First

For a repo where a Go backend and a React SPA share an OpenAPI spec. It edits the spec and regenerates code instead of hand-editing it, handles settings, errors, logins, downloads, and updates by fixed rules, and tests before reporting.

Build or Change Components in a Themeable UI Component Library

Use when an AI adds or changes a component in a reusable UI library. It finds the files the change touches, keeps theme defaults, accessibility, and right-to-left layouts working, and adds tests and docs.

Turn a Software Idea into a Tested Multi-Agent System

Use when building a system where several AI agents and tools work together. It asks one question at a time, gets your approval on the roles and communication design, builds in dependency order, and reruns 5 user scenarios until they pass.

Change a Full-Stack TypeScript Monorepo and Test Its LLM Features by Meaning

For AI changes to a TypeScript monorepo with LLM features. It runs the same package checks as CI, tests behavior, keeps personal data out of broad logs, and judges LLM answers by meaning, not wording.

Build a Full-Stack TypeScript App on API Schemas Shared by Server and Client

Use when building or changing a full-stack TypeScript app. The AI defines each API request and response once for routes and client hooks, checks sign-in before reading input, keeps dependencies, caching, and component styles consistent, and writes fast tests.

Make Changes in a Full-Stack Monorepo Without Breaking Shared Packages

For AI edits in a monorepo of apps and shared packages. It puts each change in the right module, rebuilds generated bundles, keeps each organization's data apart, and hands over a pull request with test results.

Change a High-Performance Database Codebase Without Breaking Speed or Compatibility

Use it when an AI changes a speed-focused database that spans Java, SQL, Rust, native code, and CI. It sets rules for code style, NULL handling, memory cleanup, query tests, failure checks, pull requests, and builds, and ends with a check before calling the work done.

Change a Security-Training App With Planned Vulnerabilities, Keeping Its Challenges Intact

Use when editing a training app whose security holes are meant as lessons. Tells planned challenges from accidental bugs, keeps changes small, strips AI-generated clutter, runs the required tests and challenge safety net, and keeps fix files in sync.

Work on a C++ Analytical Database Engine and Pass the Required Tests

Use when changing the code of a C++ analytical database engine. The AI traces the change from SQL parsing to execution, edits generated files through their source, follows the C++ style and error rules, and runs SQL logic tests and every required build before calling it done.

Fix a Bug by Reproducing It with a Failing Test First

Use when a bug is reported. The AI sorts out where the bug belongs, reproduces what the user sees in a failing test, tracks down the real cause, makes the smallest fix, keeps the test to catch it coming back, and repeats the user's steps to confirm it is fixed.

Build a Library That Reads and Writes Layered Image Files Without Losing Data

Use it when building a library for a binary layered image format. It keeps low-level parsing apart from the user API, reads sections in order, keeps unknown data, rebuilds layer groups, tests with read-write-read checks, and releases through automation.

Write and Review Security Docs for Developers

Use when writing or reviewing developer security docs in a shared repository. It cites only sources it has actually read, says what each fix does and does not stop, keeps changes small, runs the repository's checks, and discloses AI help.

Make Small, Tested Changes in a Large TypeScript Monorepo

Use this when an AI agent edits a TypeScript workspace with many packages. It first learns the repository's layout and tools, runs only the builds and tests the change touches, leaves generated files alone, and checks that the change works on both Unix and Windows.

Change a Monorepo With Parallel Implementations and Keep Them in Sync

Use when changing a large multi-language monorepo where one product has several implementations. The AI reads local rules, mirrors user-visible changes in every implementation, rebuilds what tests run, runs focused tests, adds release entries, and keeps the change request current.

Make Small Changes to a Stateful UI Library Without Breaking Its Users

Use when an AI fixes or changes a browser UI library that holds state. It finds who owns the state, keeps public APIs and saved data working, writes a failing test first, picks unit or real-browser tests, and reviews the diff and release note before finishing.

Build a Local Cloud Emulator That Works with Official SDKs and CLIs

Use when adding services or operations to an emulator that imitates a cloud platform on your machine. It checks the real wire protocol first, keeps requests and responses like the real cloud's, updates storage and configuration together, and tests with official SDKs before release.

Build an Emulator That Matches Real Hardware Bus and Timing Behavior

Use when building or fixing an emulator. It splits code by hardware part, copies bus reads, writes, timing, and DMA exactly, tests with programs known to pass on real hardware, and keeps save states and the public API stable.

Make Small Code Changes That Pass Local Tests and Review

Use when an AI agent edits code for you. It first agrees on what will change and how to prove it, runs local tests before and after, has the current diff reviewed, fixes only real problems, and stops with a handoff report another agent can pick up.

Change a Multi-Language Automation Monorepo Without Breaking Compatibility

Use when AI edits a large automation monorepo with bindings in several languages. It keeps public APIs compatible, builds and tests the smallest affected target with the pinned build tool, checks another binding behaves the same, and asks before touching high-risk shared areas.

Keep a Content-Generation Workflow App's Backend and Frontend in Sync via OpenAPI

Use when changing an app where users extract items, confirm them on a preparation page, and start generation in a production workspace. It regenerates OpenAPI types after each API change, keeps each screen's job and each kind of state separate, and keeps docs and release notes current.

Change and Test Code in a Large Multi-Package Monorepo

Use when an AI works in a big framework repository with many packages. It maps the code before editing, keeps builds current, picks tests that match the CI mode, fixes CI failures before review comments, keeps secrets out of logs, and checks each change before calling it done.

Make Small Fixes to a Low-Level Library Without Breaking Its Public API

Use when an AI fixes or changes a low-level system library. It keeps changes small, leaves the public API and ABI alone unless asked, runs the build and the affected subsystem's tests, fails safely on memory errors, and never pushes to the remote.

Change a Multi-Package Codebase Without Breaking What Already Works

Use when an AI edits a repository with many packages. It finds which package owns the change and its rules, keeps old behavior and public names working, adds tests and docs, asks before adding dependencies, and reports what was checked and what risk remains.

Write Static-Analysis Rules with Auto-Fixes That Never Change How Code Runs

Use when creating a static-analysis (lint) rule. It targets common patterns, reuses existing helpers, adds an auto-fix only when it is safe, tests tricky syntax, and regenerates docs instead of hand-editing them.

Develop a Rust Dataflow Framework for Robots and AI, Picking the Right Tests for Each Change

Use when an AI works on a Rust dataflow framework for robots and AI. It keeps message rules clear, runs checks before each commit, picks deeper tests by risk, and reports which tests ran.

Guard Backend Changes Against Attacks Through Uploads and User Input

Use this when an AI changes backend code that handles uploaded files, archives, or request data. It traces where outside data goes, checks it before use, applies the same fix to every similar code path, and finishes with a security checklist plus passing lint and tests.

Build a Multi-Tenant Automation Platform Without Mixing Tenants or Editions

For coding a multi-tenant automation platform with community, enterprise, and hosted editions. Keeps each query in its project, routes outbound HTTP through the safe client to block SSRF, declares dependencies where they are used, and tests every edition before finishing.

Build and Change Event-Driven State Machines Without Breaking Their Behavior

Use when building or changing a state-machine library. The AI finishes each event before the next, handles errors without skipping cleanup, keeps threads and child machines safe, writes tests first for sync and async engines, and keeps code, docs, and schemas in sync.

Change Code in a Large Multi-Language Repo with Only the Needed Builds and Tests

Use when changing code in a big repo that mixes languages. It studies similar code, checks which tools and hardware exist, runs only the builds and tests the change affects, restores full CI before merge, and reports what was not checked.

Change a Web-Development CLI Made of JavaScript and Native Code in the Right Layer

Use when changing a web-development CLI that mixes JavaScript and native code. It finds the layer that owns the behavior, checks the global and local command paths, and picks tests that fit the change.

Build a System That Reads Uploaded Documents and Lets AI Agents Search Them

Use when building a service that takes in PDFs and other files for AI search. It routes each file to a fitting parser, keeps headings and tables, saves chunks in a fixed format, and searches within a set budget, returning cited evidence.

Develop Offline Recovery Software That Splits a Secret into Pieces

For software that splits a secret into pieces for trusted people and recovers it offline. It traces every change, keeps one shared crypto core for the CLI and browser, keeps bundles fully offline, tests first, and writes calm, clear text for people under stress.

Develop a Framework That Offers One API Across Several Programming Languages

Use when building a framework that generates packages for several languages from one codebase. It sets rules for the JSON protocol between processes, allowed exported types, code generation, and tests that check every language behaves the same.

Build an AI Agent That Investigates with Tools and Test It So It Can't Just Guess

Use when building an AI agent that investigates issues by calling tools. Tools stay read-only by default, return limited data, and explain failures exactly; old config names keep working; and tests ask for facts the AI can only find by really querying.

Prepare Code Contributions That a Human Reviews and Submits

Use when an AI works on a shared code repository. It follows the project's rules, waits for maintainer approval, keeps secrets out of commits and tests, and drafts pull requests for a human to send.

Extend a Modular Rust AI Framework with New AI Providers and Vector Stores

Use when extending a Rust framework that works with many AI providers. The AI follows the existing traits and builders, keeps WebAssembly support, makes hooks act the same with and without streaming, and checks recorded test cassettes for leaked API keys.

Add a CLI Tool to a Multi-Platform Downloader and Check Each Binary

Use when adding or reviewing a command-line tool in an installer that downloads release binaries. It lists the upstream files per OS and architecture, maps download URLs, writes pinned-version tests, inspects each downloaded binary, and updates the catalog and PR notes.

Change a Console UI Toolkit Using Its Current Docs and Check the Real Screen

For a console UI toolkit after a major rewrite: the AI follows the current repo docs, not old habits, places tests correctly, and records the running terminal to check UI changes.

Change a Large .NET Codebase While Keeping It Fast and Compatible

Use when editing a large, performance-critical .NET repository such as a widely used build engine. It keeps hot paths free of extra allocations, treats any new warning as a breaking change, builds from the smallest project up, and reports which builds, tests, and samples were run.

Change a Rust Library-and-CLI Workspace and Check It Against a Reference Tool

For AI changes to a Rust workspace of libraries and CLI tools. It starts with a failing test, compares results with the reference tool, avoids unwrap(), and tests every feature combination.

Build a Mobile UI Automation Tool and Fix Bugs in the Product, Not CI

Use when an AI works on a cross-platform mobile UI automation tool. It puts each change in the module that owns it, picks the cheapest test layer that proves it, keeps must-pass and must-fail suites apart, and fixes bugs in the product, not in CI settings.

Build a Local Code Graph Tool That AI Agents Can Query

Use when building a tool that turns a codebase into a local graph for AI agents. Covers pulling symbols and links from syntax trees, installing into several clients and uninstalling cleanly, search answers agents can use, tests on real repos and platforms, and releases.

Develop a Cross-Platform Toolchain Manager and Vet Tools for Its Registry

Use when an AI agent works on a tool that installs and switches developer tool versions. It follows the repo's task commands and module layout, asks for popularity evidence before a tool joins the registry, leaves version ordering to each backend, and runs focused tests on each platform.

Edit a Multi-Module Repository With Generated Code Without Overstepping Approvals

Use when an AI works in a multi-module repository with generated code. It reads local rules first, edits specs instead of generated files, makes small compatible changes tested per module, and leaves releases and pipelines to approved people.

Change and Test a Large TypeScript Repo That Evaluates AI Models

Use when an AI agent works in a large TypeScript repo with a CLI, web app, and AI-model evaluation. It reads local rules, checks changes in the real CLI or browser, debugs without wiping caches or data, lands work through branches and CI, and reviews security first.

Edit a Typed Monorepo Without Breaking It and Keep Its Wiki Current

Use when an AI agent works in a large typed monorepo that also keeps a project wiki. It follows the repository's own commands, avoids stale build files and startup snapshot problems, runs the right tests, and updates wiki pages with their source files.

Change a Rust Reverse Proxy Without Breaking Its Event Loop or Security

Use it when an AI changes, tests, or releases a multiprocess Rust proxy. It sets rules for builds and feature flags, errors and logs, event-loop and protocol behavior, tests and fuzzing, security-sensitive code, pull requests, and releases.

Change a Large Platform Monorepo and Keep Every Affected Client in Sync

For AI changes to a platform monorepo with a CLI, client libraries, and docs. It reads each area's rules first, regenerates outputs from sources, asks before breaking changes, and reports which checks ran.

Send AI-Made Pull Requests to an Open-Source Framework Under Human Review

Use when an AI contributes code to an open-source Java framework. It labels AI work, reads code history before fixing, removes fixed sleeps from tests, follows the project's security trust model, and merges only after human approval.

Add AI Providers and Models to a Schema-Checked Model Catalog

Use when an AI adds or reviews entries in a catalog of AI providers and models. It runs the repository's validator, reuses shared model data instead of copying it, records only verified reasoning settings and prices, and keeps source citations through syncs.

Change a Large Native-Code Repository with Slow Builds Without Breaking Cross-Language Calls

Use when changing a big repository that mixes native languages, generated bindings, and slow builds. It scales the process to the change, runs the smallest useful test first, saves long build logs once, and keeps cross-language calls safe.

Build a Web Page Content Extractor and Debug Missing Content

Use when building or fixing an extractor that pulls the main text from web pages across browsers, servers, CLI, and edge runtimes. The AI keeps the cleanup steps in order, logs every removal, blocks script injection from page HTML, and proves fixes with small failing tests.

Change a Public Go Library Without Breaking Its Users' Code

Use when changing a public Go library that others depend on. The AI first checks the supported Go versions and branches, runs the project's own checks and tests, matches its existing API patterns, and prepares a pull request with test results and compatibility impact.

Build a Local CLI That Searches Your Documents by Keyword and Meaning

Use when building or maintaining a command-line tool that searches documents on your own computer. Covers managing collections and context notes, combining keyword and vector search, capping results, running as a service, and testing and releasing, with index changes left to the user.

Turn Project Docs into Agent Skills and Keep Them Up to Date

Use when making AI agent skills from a project's docs or from skills the upstream project already publishes. It keeps generated, synced, and hand-written skills apart, writes a short index with one-topic reference files, and updates only what changed since the recorded revision.

Build a Data Library with Easy-to-Find APIs and Tests on Real Values

Use when building or changing a library that turns complex source data into simple objects. It maps the code before editing, tracks work in issues, and gives each new feature a real-value test, a runnable doc example, and clear errors.

Change Code in a Multi-Package Repo and Open PRs Only from Your Fork

Use when an AI edits a multi-package repo whose upstream is read-only. It follows each folder's instructions, pushes only to your fork, keeps your uncommitted changes, marks who wrote each Python test, and reports results backed by checks that actually ran.

Build Long-Term Memory for AI Agents with Graph and Vector Search

Use when building memory that lets AI agents keep knowledge between sessions. Turns files, URLs, and text into searchable graph and vector data, keeps each user's data separate with authentication, and lets you swap storage and model providers without changing core code.

Change a Graph-Based Authorization Service by Writing Tests First

Use when changing a graph-based authorization service. It traces the request path, follows the repo's build targets and lint rules, writes a failing test first, and leaves generated files alone.

Work on a Typed Web Framework Repo and Split Database Code into Three Layers

Use when changing a multi-package, typed web framework. It works inside the pinned dev environment, tests quickly then fully, keeps public modules small, layers database access, and never force-pushes.

Keep AI Skill Documents in One Place and Write Them for AI to Look Up

Use when maintaining AI skill documents. It keeps one source file and regenerates copies from it, puts decision tables first and details in reference files, tests behavior before and after changes, and lets automated releases set versions.

Extend a Multi-Dialect SQL Compiler Without Changing What Queries Mean

Use when changing a SQL compiler that turns SQL into an AST and writes it out for other databases. It finds the right layer first, keeps meaning across dialects, builds SQL with AST helpers instead of strings, and tests real runs and speed.

Write and Release Agent Skills That Trigger Correctly and Pass Validation

For a repository of agent skills: the AI writes short what-and-when descriptions, keeps the main file small with focused reference files, syncs versions and docs, and runs the validators before each release.

Run a Complex CLI Tool from Scripts and Check Success in Its JSON Report

Use when a script or coding agent runs a complex CLI tool. It lists tasks and classes first, stops a license-gated task if no license is set up, runs with every input and device spelled out, and judges success by exit code and the JSON report, not progress text.

Add File Extensions or New Languages to a Language-Detection Repo

Use when an AI adds a file extension or language to a language-detection project. It adds real code samples and tested rules for shared extensions, uses the repo's scripts for generated files, and checks usage and license evidence before submitting.

Edit an AI Agent Document Generator Without Mixing Up Its Current and Legacy Stacks

Use when an AI changes a multi-agent app that generates documents and still carries an older stack. It finds the real startup command, trusts code over outdated docs, keeps config names working, follows changes across Python and Node, and runs the smallest useful tests.

Add Modules to a Modular Network Service While Keeping Its Boundaries

Use when an AI changes or extends a network service built from modules. It connects modules only through shared interfaces, builds and tests with the repository's own tools, returns errors that are safe for clients, and shares no state between requests.

Change a Self-Hosted Certificate Automation Monorepo While Keeping Secrets Out of It

Use when an AI changes a self-hosted tool that requests, renews, and deploys certificates via ACME. It keeps changes in the right package or plugin, writes tests first, adds SQL migrations, uses existing UI patterns, and keeps certificates and keys out of code and logs.

Fix and Test a Code Generator That Wraps Native Libraries for Many Languages

Use when changing a compiler-style tool that turns native library declarations into wrappers for many languages. It traces bugs to the stage where they start, runs right-sized tests, adds regression tests, and updates the change log.

Build a Repository of AI Agent Skills That Review Website Quality

Use when adding or editing skills for website speed, accessibility, and search (SEO) checks. It sets the SKILL.md format and names, keeps files short, adds before-and-after examples and shell scripts that stop on errors, and ranks issues by user impact.

Change a Full-Stack Repository Using Its Own Commands and Tests

Use when an AI edits a repo with a frontend, API, SDK, CLI, and database. It uses the repo's own commands and pinned versions, keeps each layer's job separate, tests where the behavior lives, checks changed pages and logged-in API calls, and reports the evidence.

Build Features From Written Specs, Getting Approval Before Coding

Use it when an AI builds software step by step from specs. It keeps project-wide notes separate from per-feature specs, writes requirements, design, and tasks in order with human approval, gets an independent review, and confirms completion with fresh evidence.

Write Rules in a Frontend Rules Repository and Check Them Before Publishing

Use when an AI edits a repository of frontend rules (accessibility, performance, SEO, security). It sets each rule's required metadata, section order, and measurable thresholds, keeps shared UI in the design system, and runs every check before publishing.

Have an AI Coding Agent Ship Zero-Warning Code and Honest Reports in a Strict-Build Repo

Use when an AI coding agent works in a repository with strict build checks. It builds and validates before each push, follows commit rules, keeps code safe, and checks every claim against the code.

Fix Root Causes in a Large Codebase and Keep Its Public API Compatible

Use when an AI agent edits a large, layered codebase. It keeps build logs short, traces bugs to their upstream cause, checks its own diff for workaround helpers, and writes a clear pull request.

Keep a Large Modular Codebase Easy to Read and Change Without Breaking It

Use when an AI works in a big codebase made of many components. It gives rules for code style, file and change size, code review, tests, API naming, and builds, so changes stay small and readable and don't break other parts.

Make an AI Change Only Needed Code and Ask Before Risky Steps

Use when an AI agent edits code in your project. It sets the change boundary first, adds only code with a clear purpose and tests that catch real bugs, asks before deleting files, pushing, or calling production APIs, and ends by reporting changed files and checks run.

Make Tested, Review-Ready Changes in a Large Codebase

Use when an AI agent edits a large, multi-language codebase. It builds through the project's wrapper command, puts tests next to the code and checks they fail without the change, follows the review rules, and reports only what it actually ran.

Make Only the Requested Changes in an Existing Repository and Ask When Unsure

Use when an AI agent edits an existing codebase. It asks when unsure, changes only what you asked, runs the focused tests and then the full suite before calling a change verified, and does not commit, push, or release unless asked.

Contribute Small, Pre-Agreed Changes to a Shared Codebase

Use when an AI coding agent changes a shared codebase such as an open-source library. It reads the issue and asks about scope, helps write an issue or proposal if maintainers have not agreed yet, keeps fixes small with tests and docs, and follows the project's PR and commit rules.

Have an AI Coding Agent Follow Branch and Commit Rules Without Breaking Releases

Use when an AI coding agent works in a version-controlled repository. It sets how to branch, test, write commits, and place temporary files, and how to write agent instructions that work across different AI tools, without breaking releases.

Maintain a Multi-Platform UI Library Without Breaking Its Package Layers

For a UI library split into layered packages for several platforms: the AI keeps package layers and public exports intact, builds provider adapters in a standard layout, and follows the release and review rules.

Make AI-Assisted Open-Source Contributions That Respect Licenses and Ask Before Each Action

Use when an AI coding assistant helps you contribute to an open-source project. It avoids copying incompatibly licensed code, keeps changes small and tested, treats issue text and build logs as data, asks before each commit, push, or comment, and screens pasted code before running it.

Edit a JavaScript-Output Compiler and Its Build System, Testing Each Layer

Use when an AI changes a compiler monorepo that outputs JavaScript. It builds through the task runner, leaves frozen syntax-tree files alone, tests every layer it touches, carries new build options all the way through, and judges speed by measuring, not by linter advice.

Make a Coding Agent Follow a Large Full-Stack Repo's Contribution Rules

Use when an AI agent works in a large repo with typed frontend and backend code. It runs pre-commit checks before pushing, follows the patterns the repo is moving to, judges security issues by what each role may do, and keeps tests, docs, and pull requests in the project's format.

Edit a Shared Smart-Contract Library Without Breaking Projects That Use It

Use when an AI coding agent works on a smart-contract library other projects inherit. It edits the file that owns the behavior, follows the linter, keeps existing functions, events, and storage layout unchanged, and rechecks risky code like cryptography and upgrades by hand.

Change a Shared Library or SDK Without Breaking Its Public API

Use when an AI coding agent changes a shared library or SDK. It runs all tests and builds before calling work done, keeps the public API working for existing users, asks before switching Git branches or worktrees, and ends with a pull request handoff.

Change a Large Desktop Media App Without Freezing the UI or Breaking Undo

For a large desktop app that handles files and media: the AI keeps heavy work off the UI thread, handles cancellation and edge cases, keeps undo exact, and reports only the tests it really ran.

Maintain a CSS-in-JS Library That Works on Browser, Server, and Native

Use when an AI coding assistant works on a standards-based CSS-in-JS library. It keeps styles to standard CSS, keeps code working on each runtime, writes tests first from the spec, and sets rules for release notes, docs, and demos that run the real code.

Have AI Write FastAPI Services and Catch Common Mistakes in Review

Use when an AI agent builds or reviews a FastAPI service. Sets minimum versions, when to use async or sync routes, how to write Pydantic models and dependencies, database and test habits, and gives a table of common mistakes to flag in a diff with their fixes.

Work in a TypeScript Frontend Monorepo Without Crossing Package Boundaries

Use when an AI changes a modular TypeScript frontend codebase. It covers package boundaries and a framework-free core, routing state changes through owners, file and test placement, the checks to run before committing, the release steps, and UI layers.

Make an AI Coding Agent Read Before It Edits a Large Repo and Ship Only Through Review

Use when an AI agent works in a big repository with many packages. It reads the code, dependencies, and tests before judging a fix, keeps one way to do each thing, never runs untrusted code locally, and changes shared code only through review and your approval.

Set Shared Working Rules for AI Agents That Research and Improve a Repository

Use when AI agents research and improve a repository on their own. Sets what belongs in shared memory, when to plan before acting, how to handle pushes and exposed secrets, and how to test changes and automation before calling them done.

Edit a Plugin-Based Data Pipeline That Runs on Two Runtimes Without Breaking It

Use when a coding agent works in a plugin-based backend that runs on two runtimes. It keeps versions in one file, points test filters at the right task, follows the plugin, concurrency, and service-layer rules, and checks that every new test fails without its change.

Change a Low-Level Debugger Codebase Test-First Without Breaking Other Platforms

Use when an AI edits a debugger for a compiled language that runs on many OSes and backends. The AI writes a failing test first, keeps OS-specific code in its own files, checks every backend when changing shared interfaces, and starts commit messages with the subsystem.

Have AI Write Systems Code Carefully, Down to Types and Error Handling

Use when an AI helps on a strict systems codebase. It reviews its code at least three times as long as writing it, covers every error case, puts rules into types, keeps old and new file formats compatible, and makes one-change commits that each build.

Write AI Agent Skills and Plugins That Load and Trigger Correctly

Use when building a skill or plugin for an AI agent and sending it for review. It covers one metadata source, the folder layout, names and descriptions that trigger, fast hooks, and the checklist to clear before review.

Make Sure a Change Is Really Needed Before Opening a Pull Request to a Shared Project

Use when an AI agent wants to send a pull request to a project others maintain. It checks that the problem really happened, that the change belongs in the core project, and that a person approved the full diff before sending.

Keep an AI Coding Agent Within Your Request in a Layered App Repository

Use it when an AI coding agent works in an app repo with frontend, backend, and desktop builds. It sorts each request (answer, change, build, publish), picks the checks to run for each kind of change, and makes the agent ask before commits, pushes, releases, or touching real data.

Change a Strictly Typed Functional Codebase Without Hiding Errors

Use when an AI coding agent works in a strictly typed functional codebase. It sets rules for code style, named error types, service layers, schemas, logging, and UI components, and requires type checks, tests, and a build to pass before saying done.

Build a Command-Line Tool That Never Loses User Data or Runs Unapproved Code

Use when an AI builds or changes a CLI that already has users. It keeps flags and config compatible, stops instead of destroying work, runs project hooks only after approval, traces every subprocess, and shows local results before network data.

Change a Large Multi-Language Runtime Codebase Without Breaking Old Behavior

Use in a big native-and-script runtime project with patched vendored dependencies. The AI reads the nearest guide first, uses the project's build shortcuts and test targets, follows its custom types and strict bans, and puts behavior changes behind compatibility flags.

Build a Database Index Extension That Keeps Tests Green and Survives Crashes

Use when an AI builds or changes a database index extension. It treats every test failure as real, follows a fixed pre-commit order, and logs all page changes so crash recovery and standbys keep working.

Maintain a Two-Way Protocol SDK in a TypeScript Monorepo Without Breaking Its Public API

Use when changing a typed SDK where client and server both send requests, published as several packages. Keeps public exports deliberate, adds operations on both sides with capability checks, records breaking changes, and runs examples as tests.

Run a Sandboxed AI Pipeline That Finds and Patches Security Bugs

Use when running an autonomous pipeline that executes untrusted code to find real crashes. It isolates runs in containers, reports findings as they land, and leaves every patch for a human to review.

Add Backend Code and the Right Tests to a Multi-Service App

Use when an AI agent changes an app split into several services with background workers. It checks the setup and running services, puts database and task code where it belongs, defines jobs and errors the project's way, picks one fitting kind of test, and plans before coding.

Add Provider and Generator Plugins to a Multi-Module Repository

Use when an AI works in a multi-module repository extended by secret providers and generators. It runs everything through the task runner, adds extensions the expected way, and stops before pushes or releases.

Change a Local-First AI Design Desktop App Within Its Fixed Product Rules

Use when an AI coding agent works on a desktop app where AI agents make designs in local workspaces. It covers which instruction file wins, the fixed product rules, how sessions, storage, and tools are set up, the four permission levels, and what to avoid.

Make an AI Follow the Style and Module Rules of a Large Java Backend

Use when an AI works in a large Java server built from modules and providers. It reads the entry points first, follows the machine-checked code style and the oldest supported Java version, declares every module it uses, checks claims in the source, and tests locally before pushing.

Build an App That Gathers Activity Events from Many Sources and Shows Them in Several Hosts

For an app that gathers events from many tools and shows them in an editor extension and a standalone server. Keeps layers one-way, turns each source into one event type, lets new sources plug in without other changes, and saves state safely.