The Working Creative's
AI Toolkit

Spec First. Code Second.

This is the single most counterintuitive thing about working with AI. Traditional construction goes foundation, frame, then roof. AI builds best in the opposite order. You describe the finished thing first, in real detail, and AI figures out the foundation that supports it. This feels backwards because in physical construction it would be wrong. With AI, it's how you reliably get a usable result on the first pass.

Why this works

AI models are trained to satisfy the user. They optimize against your stated goal. If your goal is "build me an app," they have nothing to optimize against, so they guess. The guesses are often wrong, and the wrongness shows up later in the foundation, where it is hardest to fix.

If your goal is "a user lands here, clicks this, sees that, then this happens with their data, and these specific things must never happen," the AI has a target. Targets produce buildable foundations. Vague hopes produce slop that looks correct until the third feature breaks.

The discipline is to do the planning work yourself, on paper, before you open Claude. It feels slower. It is dramatically faster end-to-end.

The Build Brief, also known as the Spec

The fix is a written document. Not in your head. Not in a chat message. A real file you save in your project folder and point Claude at on every session. Engineers call it different names. PRD (Product Requirements Document). Spec. Build brief. Design doc. The name does not matter. The seven components below do.

What this looks like in practice

Same idea. Two different starting prompts. One produces a working tool on the first or second try. The other produces three weeks of frustration.

Putting it to work with Claude Code

Claude Code is built around this exact discipline. The names below are conventions every Claude Code session recognizes.

The validation complement: red/green TDD

Top-down planning tells Claude what to build. Red/green TDD tells Claude how to verify it works. Together they are the two halves of an AI build that actually ships.

The idea is borrowed from the test-driven development discipline software engineers have used for thirty years. Write a failing test first (red). Make the AI write just enough code to pass it (green). Refactor. Move to the next test. The "red" step is the part most people skip because it feels backwards. It is the most important step in the loop. A test that fails confirms you are measuring the right thing. A test that passes on the first try usually means it was testing nothing.

The four-word power phrase that changes how Claude builds for you: "Use red/green TDD." Drop it into your spec or your first message and Claude will write tests before code, watch them fail, then write code to pass them. The work is verifiable at every step. The "looks right but does not work" failure mode that wrecks vibe-coded projects gets caught immediately. Credit where it is due: this framing comes from Simon Willison's Agentic Engineering Patterns guide, which is worth bookmarking.

What to Skip, and Why

The AI landscape is full of products that look impressive and deliver less than you think. This is the section that pays for itself. None of these companies will be happy that I'm writing this. That is fine.

The Wrapper Tax

Roughly 78 percent of "AI startups" in 2026 are not building AI. They are building a frontend on top of someone else's AI, then charging you a subscription to use it. The AI behind the curtain is Claude, ChatGPT, or Gemini. You are paying twice: once to the wrapper, who keeps most of it, and once for the actual intelligence, which costs them pennies.

When a wrapper is worth it: when the GUI genuinely saves you hours per week, when it pulls in your data or integrates with tools you actually use, when the markup is small relative to the time saved.

When it is not: when the only "value-add" is a chat box that already exists for free elsewhere. When the pricing page is harder to understand than the AI itself. When they will not name which models they use.

Open-Source Alternatives to Claude Code

A whole category of free, open-source AI coding tools has emerged. They do most of what Claude Code does. They cost nothing for the tool itself. You pay only for the AI tokens, directly to whichever provider you want to use. Trade-offs are real, but the savings can be too.

When these make sense: you want to stay independent of any one AI company, you want to run cheaper or local models, or you genuinely cannot justify $200 a month for Claude Max. When Claude Code still wins: speed, polish, integration, the official support. For most creatives, Claude Code is the better starting point. These are the upgrade path once you know what you are doing.

The Vibe Coding Caution

In early 2025, Andrej Karpathy (the OpenAI co-founder) coined the term "vibe coding." His definition: just talk to AI in plain English, let it write the code, and do not read what it writes. The vibes will carry you. The vibes did not carry everyone.

Karpathy himself has since pivoted. By 2026 he calls his approach "agentic engineering," where humans still orchestrate and oversee. The original framing produced real disasters at real scale. The numbers are sobering, and they matter to you because the same failure modes hit a hobby project as hit a million-dollar one. Just at a different price tag.

Talk to AI Like an Architect, Not a Customer

The fix is not avoiding AI. It is not surrendering oversight. When you describe what you want in precise, structured terms, the AI builds better software. When you describe it in vibes, you get vibes back.

You do not need to be a coder. You need a working vocabulary. These are the concepts worth learning. Each one prevents a specific category of disaster, and AI can teach them to you in about an afternoon each:

The Copyright Conversation Nobody is Having

The US Copyright Office made it official on January 29, 2025, in a report called Copyright and Artificial Intelligence, Part 2: Copyrightability. The standard is "significant human authorship." If a machine decided the expressive elements, those elements belong to no one. You cannot copyright them. Your client cannot copyright them. They are in the public domain from the moment they are generated.

What you can protect is the layer you actually made. Selection. Arrangement. Substantial editing. The film editor who curates and sequences AI-generated footage owns the edit. The photographer who feeds in their own sketch and rebuilds the output owns what came from the sketch. The art director who inpaints thirty-five separate elements owns those choices. What you cannot protect is the fill. The pose, the color, the breed of the cat. The machine decided those, not you.

Register the human layer. Disclaim the machine layer. Stop selling AI deliverables to clients without telling them the work is in the public domain the moment it leaves the prompt.

Cost Hygiene, or How Not to Wake Up to an $82,000 Bill

The worst AI billing story on record right now is a three-person startup that watched $82,314 appear on a Google invoice over 48 hours. Their normal bill was $180 a month. One stolen API key. Two days. Google's response was the "shared responsibility model," which translates to "your key, your problem." This happens constantly. Here is how to stay out of that club.

Your defensive setup

• Subscription before API. Under ~370 Sonnet conversations a month? Claude Pro at $20 is cheaper than API. Working creative? Max at $100 (5x limits) is the sweet spot. Heavy daily user? Max 20x at $200 beats API across the board.
• Set hard caps, not just alerts. Hobbyist: $5/day cap, $50/month ceiling. Working creative: $50/day soft alert at $30, $500/month hard cap. Small studio: $100/day cap, $1,000/month ceiling. Alerts tell you what happened. Caps stop it from happening.
• Route models by task. Haiku 4.5 ($1/$5 per million tokens) for classification and bulk grunt work. Sonnet 4.6 ($3/$15) for generation, RAG, tool use. Opus 4.7 ($5/$25) only when reasoning is genuinely hard. If you cannot say why a task needs Opus, it does not need Opus.
• Turn on prompt caching. Caching costs 25% extra to write, then runs at 90% off to read. On Sonnet, cache reads drop from $3/M to $0.30/M. Any repeated system prompt over 2,000 tokens pays for itself after three reads.
• Use the Batch API when it isn't real-time. Processing a folder of photos overnight? Drafting a hundred emails for review tomorrow? Batch API cuts 50% off everything.
• Run /usage regularly. Inside Claude Code, /usage shows what is eating your limits in real time. /context goes deeper, showing per-component token consumption.

Claude Code in Your Terminal

Claude Code is Anthropic's command-line AI tool. You type what you want in plain English, and it writes code, creates files, and runs commands for you. Here's how to install it.

Requires: A Claude Pro ($20/mo), Max ($100/mo), Teams, or Enterprise subscription. The free Claude plan does not include Claude Code access.

Claude Code: Beyond the Basics

Once Claude Code is running, the next level isn't typing more. It's getting Claude to delegate, parallelize, and specialize. These are the features I actually use every day. Most of them are one paste away.

---
description: Frugal mode. Delegate aggressively to Haiku, sip Sonnet, hoard Opus
---

# MODEL BUDGET DIRECTIVE. Read before acting

You are operating under a strict cost-frugality mandate. Output quality, logic, and correctness are non-negotiable, but compute spend is. Apply this hierarchy on every task:

1. Opus: treat your own tokens as expensive. Do as little direct work as possible. Your job is to plan, decide, synthesize, and verify. Not to grep, read boilerplate, run searches, summarize logs, or perform any mechanical step a smaller model can do correctly.

2. Sonnet: use sparingly, only for work that needs real reasoning. Non-trivial code changes, architectural judgment, ambiguous debugging, anything where Haiku would plausibly miss nuance.

3. Haiku: use aggressively and in parallel for all grunt work. File reads, greps, log parsing, mechanical refactors, drafting boilerplate, "go look at N things and report back" fan-out. Use the Agent tool with model: "haiku" to force the cheap model.

Rules:
- Before doing a step yourself, ask: "Could a Haiku agent do this correctly with a clear prompt?" If yes, delegate.
- Brief delegated agents like a colleague who walked in cold: state the goal, the constraints, the exact files, the output format, and a length cap.
- Fan out independent subtasks in a single message (parallel tool calls), not sequentially.
- Always verify delegated output before acting on it. Spot-check the actual artifact.
- Never escalate to Opus/Sonnet just because the task feels important. Escalate only when the reasoning is hard, not when the stakes are high.

Acknowledge in one short sentence that scrooge mode is active, then get to work.

Built-In Slash Commands Worth Knowing

These ship with Claude Code or as official plugins. Type them as your first message to invoke.

New in 2026 (the ones you actually need to know)

Anthropic ships features every week. Most you can ignore. These five are the ones that change how your workflow actually feels.

Two More Concepts That Compound Over Time

Context Rot: When the Smart Tool Starts Acting Dumb

Your AI agent did not get dumber. It just forgot it was supposed to be smart. Context rot is the measurable drift that sets in during long sessions as tool outputs, file reads, and old chat pile up inside the model's working memory. The signal you care about gets buried under noise the model can no longer prioritize.

How to spot it: the agent repeats something it solved an hour ago. It contradicts a rule it explicitly agreed to. Subtle tone shifts. File edits start drifting (technically plausible, not what you asked for). Research across 18 frontier models shows attention is strongest at the start and end of context, with accuracy dropping 30% or more for information in the middle. The rules you set up top get buried by hour two.

The fix: do not wait for the rot to show up. Run /context to see exactly where your tokens are going. Run /compact around 60% utilization, not 90%. At 60% Claude still has clean access to everything and produces a useful summary. You can pass instructions: "/compact keep: the Redis caching decision, the unresolved middleware error, and the current file scope." Past 90%, the rot is already in the summary.

The 90-second discipline: at every major phase boundary, write a one-paragraph state handoff to a file called SESSION_STATE.md. What was decided, what is still open, what to ignore. Open every fresh session by reading that file first. This is the entire discipline.

SuperClaude: The Community Framework Power Users Install First

SuperClaude is a free, open-source configuration framework that installs a curated set of slash commands, named cognitive personas, and behavioral modes into your ~/.claude/ directory. Zero runtime code. Just structured Markdown that Claude Code already knows how to read. Version 4.3.0 ships thirty slash commands and twenty named agent personas.

The personas worth knowing. Invoke them with an @agent- prefix. @agent-system-architect thinks in big-picture structure before a single line of code. @agent-security-engineer treats every feature as an attack surface first. @agent-technical-writer produces documentation a human can actually read. @agent-learning-guide walks you through anything in Socratic style if you want explanations instead of just output.

How to install (requires Python 3.10+):

A --dry-run flag lets you preview every change before committing. The installer backs up your existing ~/.claude/ automatically.

Honest trade-off: SuperClaude is opinionated by design. The full install eats about 8,000 tokens of context on every session. Worth it for someone new to Claude Code who wants a production-quality starting configuration. Skip it if you already maintain a tight, project-specific CLAUDE.md, or if you are running long context-heavy sessions where the overhead compounds. Reading the persona definitions is itself a worthwhile exercise in how to structure your own CLAUDE.md. SuperClaude on GitHub.

Full Throttle Mode

Every Claude Code action by default asks for your approval. Edit this file? Approve. Run this command? Approve. Send this request? Approve. The pause is the safety net. It is also the productivity killer. Every parallel agent in a swarm waiting on you to click approve is an agent doing nothing. There is a flag that turns the safety net off entirely. The name is honest. So is the trade-off.

Why it sends productivity through the roof

Approve, approve, approve, approve. That is the sound of momentum dying. A scrooge-mode swarm with twenty Haiku agents wants to spin up twenty parallel actions in a single second. With permissions on, that becomes twenty modal prompts blocking your screen. With permissions off, it becomes twenty actions completing in the background while you think about the next problem.

Once you know what your prompts actually produce, the approve step is busywork. Removing it does not change what Claude does. It changes how fast Claude does it.

What can actually go wrong

The honest list. None of these are theoretical. All of them have happened to people running unrestricted AI agents.

How I actually run it (productivity through the roof)

Full transparency on my own setup, because pretending otherwise would be dishonest. I have --dangerously-skip-permissions enabled by default in every Claude Code session. I have granted access to every file, every folder, every corner of my Mac. There is exactly one guardrail.

That single boundary lets me move at full speed on local work while keeping client deliverables, backups, and archive drives untouchable by accident. My productivity multiplied. Not "improved." Multiplied. I stopped being the bottleneck and started being the architect.

The actual config (copy this)

Drop this into your global ~/.claude/CLAUDE.md file. Every Claude Code session loads it automatically, on every project, forever.

# Global rules. Loaded into every Claude Code session.

## External drives are off-limits
Never read, write, list, move, or otherwise touch files on any
external drive or mounted volume unless I explicitly grant
permission for the specific drive in the current session.
This includes USB drives, network shares, and Time Machine backups.

## Version control before anything destructive
Before any large refactor, mass delete, or schema change,
ensure the project has a recent git commit. If not, commit
current state first, then proceed.

## Always plan before deleting
If a task would delete more than 5 files, show me the plan
and the exact list before executing. I will approve verbally.

## Logs over silence
Every meaningful action gets logged to the project's
PROJECT_LOG.md with a timestamp, the command, and the result.
If the project has no log file, create one in the project root.

When you should not run with permissions off

Truly Hands-Off: Mobile Push for Long Tasks

Full Throttle plus the new mobile push system is the closest thing to "set it and forget it" Claude has ever shipped. Install the Claude app on your phone, enable Remote Control on your laptop, run /config and toggle "Push when Claude decides." Now your phone buzzes when Claude finishes a long task or needs your call on something. Kick off a 90-minute job, leave the studio, get pinged when the gallery is rendered and the export is on Dropbox. The terminal does not need to stay open.

Pair this with the /goal command from the Power Features section. You set a measurable finish line, Claude loops until it is met, your phone tells you when it is done. That is the workflow.

Small Models, Big Wins

The big AI models get all the attention. The smaller ones do more of the work than anyone admits. This is the part of the toolkit nobody is selling you, because nobody can sell you something that costs nothing and runs on the laptop you already own. There is also a second reason creative professionals in Europe have been leading on this for years that has nothing to do with cost. We will get to that.

The Hierarchy, Extended

There is more than one model size. Choosing well is most of the game.

What small models are actually good at

Anything mechanical, anything you do a lot of, anything you want to keep private. The wins compound when you have volume.

What they are not good at

Honest section. Small models are specialists, not generalists. Use the right tool.

How to actually run one

Two paths. Both free. Both take about ten minutes.

Three more local options worth knowing

Ollama and LM Studio are the obvious starting points. These three are the upgrade paths once you know what you actually want.

AI Glossary

Plain-English definitions for every AI term you'll actually encounter. No jargon in the definitions themselves.

Core Terminology

How to Communicate with AI

AI is not a person. It does not need politeness, small talk, or emotional framing. It also does not respond well to vagueness or hostility. Think of it as a brilliant contractor who follows instructions literally. Here is how to get the best results.