Skills that runyour playbook

Your AI works on a branch for each change, writes commit messages you can read months later and merges cleanly, so a working version is always one step back.

Your AI reads how your codebase names things and lays out files, then writes new code in the same style so the project reads like one person wrote it.

The AI runs the change, reads what actually came back and only then calls the job done.

Before writing anything, the AI searches the codebase for a function or helper that already does the job and reuses it.

Write the failing test first, then just enough code to make it pass, and you end up with a feature that is proven to work and a test that catches the day it breaks.

The AI lays out a few real options with their tradeoffs before it plans anything, and you pick one while changing your mind is still cheap.

Point the AI at a repo it has never seen and get back a map of where things live, the entry points and how the parts connect.

The AI learns enough of a new codebase to make a real, correct change in one sitting.

Read the context, act, review what you did and verify that it works: the four-step loop under every good piece of AI work.

Point a group of agents at one goal and they split the work, share one set of tools and pass context to each other as they go.

Give it a mission and it sets up the agents for you, each with a narrow job and only the tools that job needs.

Work runs in waves ordered by what depends on what, so agents work in parallel where it is safe and in sequence where one needs another's result.

One agent watches the others, spots a stuck worker, hands a dead task to someone else and flags only what needs you.

Each task is sized and sent to a model that fits it, so simple jobs run on cheaper models and hard jobs go to the strongest one.

Keep a standing team of agents running between tasks, with a status for each one so you can see who is working and who has gone quiet.

Long jobs keep moving between the checkpoints you set, so a multi-hour task carries on without waiting for you at every step.

Every worker sends a regular signal that it is alive and making progress, so a hung agent shows up within minutes.

Anything irreversible, like a deploy, a delete or a purchase, waits for your sign-off before an agent can run it.

Each action an agent plans is checked before it runs, and anything destructive or outside its job is blocked.

Agents coordinate through plain files in a shared folder: one writes a signal and another reads it and acts, and you can see the whole state with a directory listing.

An agent runs on its own between set checkpoints and has to pass a real check at each one before it continues.

Incoming tasks are checked, shaped and sent to the right builder agent, so half-formed requests get fixed before anyone starts work.

A current list of the exact actions each tool allows, so agents call approved operations and leave everything else alone.

Each workflow gets a token and cost limit, with spend shown as it happens and a stop before one job runs the bill up.

When a workflow takes on more than it can handle, it sheds and reroutes work so the team slows down gracefully and keeps going.

Your agent keeps what it is working on now, what it learned this session and what it should always remember in three separate layers, so it stops asking for things you already told it.

Recall that combines a graph of how your facts connect with search that finds a loose match, so a vague question brings back the right fact and everything linked to it.

Tiago Forte's PARA method (projects, areas, resources, archives) applied to your agent's notes, so you can find what it learned weeks later.

Each problem your agent solves becomes a saved, reusable note, so the next time the same problem comes up it takes minutes.

Walks through your agent's memory and flags facts that are out of date, contradicted or wrong before the agent repeats them.

Memory saves itself through Claude Code lifecycle hooks when a session ends or a milestone lands, with nothing for you to remember.

When a session ends or work moves to another agent, it writes a clean handoff of where things stand, what is decided and what is still open.

Shows where loading memory changes the answer and where it only adds cost, so you spend context on the recall that matters.

A lesson one agent learns goes into shared memory the same day, so every other agent can use it.

Turns a rough idea about what you sell into landing pages, ads, emails and sales pages written from your real offer and buyer, each leading to one clear next step.

Finds the patterns that make copy read as machine-written, like clipped fragments and tidy reframes, and rewrites them in a specific human voice.

Turns your real captions, emails and posts into a written voice profile that you, a writer or any tool can use to sound like you.

Writes a batch of subject lines matched to your list and the email itself, with the reasoning behind each so you can test them and write your own.

Shows where social proof, scarcity, reciprocity, loss aversion and commitment honestly fit your offer and where pushing them would backfire.

Loads your real product details, buyer and positioning before any copy is written, so every piece starts from the facts of what you sell.

Reviews your funnel, finds where buyers drop off and ranks the fixes by likely lift so you work the top of the list first.

Builds the value stack, the proof and the risk reversal around what you sell, so the price feels small next to the promise.

Rebuilds your checkout so a buyer who wants to pay finishes paying, with no surprise fees, a short form and reassurance at the moment of doubt.

Takes a page from a blank screen to live in one pass, covering the headline, the flow, the proof and the code.

A repeatable system for selling a five-figure offer over a call, from the application to the money conversation to the follow-up that saves a maybe.

Builds the check-ins, milestones and recovery steps that keep clients paying past the third month.

Designs a members area people come back to, because members who feel lost on their first login are the ones who cancel.

Runs your live Meta campaigns toward the number you set, like cost per lead or ROAS, and keeps adjusting budget, bids and audiences to hit it.

Sets up the pixel, the Conversions API, event tracking, domain verification and account structure, so conversions report back and Meta can find buyers.

Produces a steady stack of ad variations for the Facebook feed, with new hooks, angles and formats ready before the current batch wears out.

Makes ads that fit the Instagram feed, Stories and Reels, with native pacing and captions and the offer built in.

Reviews an ad account and hands you a short, ranked list of where money is leaking and what to fix first.

A pipeline that turns one idea into a scripted, hook-first reel you can shoot in one sitting, so you can post every day for months.

Writes a video sales letter in the order that keeps a stranger watching: problem, agitation, mechanism, proof, offer and the objections you would hear on a call.

Builds a webinar that teaches something real and ends on a pitch that feels like the natural next step.

Hand-codes responsive HTML email that looks the same in Gmail, Apple Mail, Outlook and on a phone.

Maps a full email sequence with branching, so buyers, browsers and people who went quiet each get the next email that fits them.

Covers ranking in classic search and getting your brand cited in the answers people get from ChatGPT and Perplexity.

Conversation flows for DMs that open like a person, listen first and steer toward a booked call once the person has shown they have the problem you solve.

Runs a launch as one coordinated push, so the emails, posts, sales page and offer say the same thing on the same day.

Turns a course or program into something a buyer can log into, work through and finish, including delivery, access and the welcome flow.

Builds a free resource aimed at one problem your buyer is already trying to solve, which is what makes it worth an email address.

One repeatable flow that gives every new client the same confident first week.

Helps you build a deck and memo that answer the hard questions about your numbers before an investor asks them.

Python a senior developer would sign off on, with the packaging and tooling decisions already made.

Go written the way the standard library intends, including the goroutine and channel patterns that are easy to get subtly wrong.

Gets ownership and the borrow checker to click, so more of your Rust compiles on the first try without cloning everything.

Kotlin that uses null safety, coroutines and the standard library properly, on the server and on Android.

SwiftUI patterns for Apple platforms that hold up past the tutorial, with state management handled from the start.

Modern Java with records, sealed types, streams and the features added since Java 8.

React and Next.js built the way the framework works today, with the App Router and Server Components, fewer re-renders and fewer useEffect mistakes.

Django models and views that stay clean as features pile on, with queries that go easy on your database.

Laravel with Eloquent relationships and routing that read like the docs, thin controllers and fast queries.

Small, reproducible container images that ship only what production needs.

Model, index and query Postgres so it stays fast past a few million rows, and learn to spot a missing index or a query the planner cannot use.

Design APIs other developers can pick up on their own, with versioning and error handling worked out before version one ships.

Lay out your services and data flow early, so the codebase stays pleasant to work in a year from now.

Node services and CLI tools that handle errors, keep memory in check and use async correctly.

Change your schema in production with no downtime, and know which migrations lock a large table before you run them.

Checks a diff for injection, broken auth and leaked secrets before it ships.

Tests signup, checkout and login in a real browser after every deploy, with tests written to stay stable.

Deploys to Vercel and confirms the deploy actually works, with preview deploys, environment variables and build settings handled.

Turns the design sense you feel but cannot name into rules the AI can apply, like spacing ratios, optical alignment, contrast and hierarchy, so the output looks like a designer made it.

Handles the final polish people notice, like tighter spacing, settled type and small details, so an AI-built screen looks professionally designed.

Build a theme once as design tokens for color, type, spacing, radius and shadow, and reuse it so every page looks like the same product.

Keeps your layouts holding their shape from a 375 pixel phone up to a wide monitor, with text and buttons that stay where they belong.

Write Tailwind and similar utility classes correctly the first time, so you are never stacking overrides to fight a default.

Every review finding gets a confidence score, so the serious bug sits at the top of the list and the hunches sit at the bottom.

A five-step review pass that catches buried assumptions, untested edge cases and requirements that went missing, the same way every time.

Makes the AI push back when you are wrong, so its feedback is worth acting on.

Runs your proposal past a skeptical CFO, a skimming executive, a lawyer and a customer, so you hear their objections before they raise them.

For a decision you are torn on, several agents argue different positions and you see where the strongest case lands.

Assume the project already failed and work backward to the reasons, while there is still time to design around them.

Tracks what every agent and workflow spends and caps it before the bill surprises you.

Makes the model back its claims with real sources and check them before it states them, so you can trust what comes out.

Checks your live CRM records against your rules and hands you the exact rows with missing consent, duplicates or wrong stages.

One standard path from idea to shipped capability, so everything your team builds is documented, tested and reusable.

Walks you through writing a skill with the correct structure and metadata, so it loads and triggers the first time.

Versions and bundles a set of skills so someone else can install them cleanly.

Scores agent output against tasks with rubrics, so you can tell with numbers whether a prompt change helped.