If the response has code blocks, a picker lets you grab just one instead of the whole thing. Pass a number to reach further back: /copy 3 copies the third most recent response. Press w to write to a file instead of the clipboard.

> /copy

   Select content to copy:
   ─────────────────────────────────────────────
 > 1. Full response
   2. Code block (sql)   SELECT id FROM users…
   3. Code block (sql)   WITH active AS (…)
   4. Code block (sql)   SELECT count(*) FROM…

   ↑↓ navigate   ↵ copy   w write to file

I reach for it when Claude writes a query or a config block and I want it in the editor without selecting across a scrolled terminal.

I quote the work, not the hours. Eight weeks, fixed scope, a number you can put in a budget. If I’m wrong about the estimate, that’s my problem to solve, not a line item on your invoice.

This only works because I write the code myself. There’s no team to staff, no margin to pad, no handoff where the estimate quietly doubles. You’re hiring the person doing the work.

Concrete beats abstract. A fixed number you can plan around beats a rate card and a hope.

Write the eval first. Pin the cases you care about. Measure before you claim the feature works.

1def test_extraction(model, cases):
2    passed = 0
3    for case in cases:
4        result = model.extract(case.input)
5        passed += result == case.expected
6    return passed / len(cases)

An eval is not a unit test. It is a measurement you keep running as the model, the prompt, and the data drift underneath you. Treat the score as a contract.

The discipline is old. The subject is new. That’s the whole job.

A team I worked with had a system changing faster than they could spread the knowledge around the company.

Every consultant says “build a RAG.” What they leave out is the data pipeline underneath it: engineering effort, time, money.

The team uses Elixir, which keeps documentation next to the code and exports it as Markdown. I exposed that documentation through /llms.txt, a plain text file at a known URL that tells AI tools where to find your docs.

Another microservice? Another line in the file.

Anthropic does this for Claude’s own docs. Ask Claude about its features and it uses the claude-code-guide skill, fetching Markdown from the public internet.

Within a couple of hours, product managers and analysts could see exactly how the product behaves in production, with no new tools.

Even in AI, fundamentals win.

Examples of what success looks like, plus references to similar past work, let Claude ship a feature in 20 minutes. The ticket becomes the spec.

I use Claude Code’s plan mode. It explores the codebase, interviews me to clarify the requirements, and lays out a multi-step plan. I just say “implement ticket XX.” Activate it with Shift+Tab in the CLI.

“What should I put in my CLAUDE.md” is the question I hear most from engineers trying to speed up their work.

The common mistake is treating it as documentation for product managers. “We’re explaining what the code does anyway, so we’ll use it as docs.” Wrong.

Give Claude directions for finding the right information.

Bad: “In the class Calculator I export the methods sum and subtract.”

Good: “To do math, look at the Calculator class.”

Mid-sized companies treat documentation as nice to have. Agile made it feel useless, so teams stopped writing it.

Your agents need context to work across your stack. That makes documentation a moat.

Stop asking agents to “research this codebase thoroughly.” Document it once. Save the tokens.

MCP servers port existing APIs into something agents can use. They also eat your context window with verbose definitions.

Skills are small markdown files with instructions for using CLI tools. They load into context only when your question matches the skill’s description.

I tested reading my reminders list through Claude Code. The Skill used 40 tokens. The MCP server used 749. Multiply that across the dozens of tools a power user touches and Skills scale better.

Some of your MCP servers are a markdown file waiting to happen.

For a complex feature I write a spec and hand it to the agent to turn into an implementation plan. What goes in it:

• Introduction. “You are building a dashboard to change settings on a security platform.”
• Problem. If it knows why, it finds solutions I didn’t think of.
• Scope. Keeps it focused on what I want.
• Out of scope. Paradoxically, this sharpens the scope.
• Functional requirements. The list of tasks to complete.
• Non-functional requirements. Respects my architectural decisions.
• References and glossary. Points it at the knowledge it should read.

The spec is where the thinking happens. The code is the easy part.

Agents feel natural enough that you start treating them like coworkers. Then you forget they can’t read your nonverbal cues.

Stop saying “this” and “that” to your coding agent. It doesn’t know what you mean. Say “do the research first, then build the website.”

I started in the browser version of Claude, learning what to do and which commands to run. No success.

So I asked it for one thing: “Give me a prompt to ask an AI to do this for me.” I pasted that prompt into Claude Code. Everything worked in two hours.

Mission critical? No. Fun? Yes. Can I watch my movies? Yes.

Claude Code is for anyone with a computer, not just developers.

Then tell it who you are. “Be a systems administrator talking to a business major with Excel experience. How can I see files that live on a different computer? We use Mac.”

I reach for this every time I start something new.

• ChatGPT Business: 30 dollars
• Claude Pro: 20 dollars
• Gemini Enterprise: 21 dollars

Unless you’re on a Business plan, OpenAI and Gemini train on your data. More on that here.

That’s 71 dollars per person on starter plans, and it climbs the moment you exhaust the quotas. Expensive, and hard to control securely at scale.

One subscription, all three, or something else entirely is a real decision.

Short answer: yes. On the Free, Go, Plus, and Pro plans, your data is used for training. On Business and Enterprise, it isn’t.

Worth knowing before you hand ChatGPT subscriptions to your team.

Jevons paradox: when a technology makes a resource more efficient to use, total consumption of that resource often goes up. Lower cost raises demand and creates more work overall.

When steam engines got fuel efficient, coal consumption rose. It started the industrial revolution, not its end.

I’ve felt it firsthand, testing 43 files in an hour. GitHub’s data shows developers using Copilot write more code, not less. Features that took weeks now get prototyped in hours by one engineer.

The question is whether you cut headcount or raise throughput.

GitHub’s research on Copilot and developer productivity.

The leaders in December 2025:

• Text: Gemini 3 Pro
• Coding: Claude Opus 4.5
• Text-to-image: GPT Image 1.5

I asked Claude and Gemini for a title for this post. Gemini was thorough: three options across three angles, with a recommendation. Claude gave me half as many and no reasoning.

Claude’s suggestion was “Are You Using the Wrong AI?”. Gemini’s is the title that kept you reading.

1. Who can answer this? Give it a role.
2. What information solves the problem? Add constraints, context, numbers.
3. What is the goal? Not “help me”. State an outcome.

Put together:

You’re a senior engineering manager who has scaled teams from 5 to 20 people.

My team of 8 developers spends 40% of sprint time on code reviews. Today: PRs need 2 approvals, no size limits, reviews happen async.

Give me 3 process changes where AI can cut this time.

The structure does the work. The role narrows the answer, the numbers ground it, the goal points it somewhere.

Here is how I tested 43 files in about an hour.

The agent

An agent is a prompt with its own context window. Each one tackles its assigned task, handles the nuances, and keeps you in the loop.

Test the prompt on a single file first. A QA engineer prompt:

Be a QA Engineer.

Analyze the given file, understand the purpose of the class, and write a unit test in <folder>.

Use a black box strategy: pass inputs, assert outputs. Don’t mock anything without planning it with me first.

Once it works, save it with /agents as “qa-engineer”.

The coordinator

Then create a coordinator that spawns agents in parallel:

Be an AI Agents Coordinator.

Unit test all of these files:

file1.ts file2.ts

Spawn one qa-engineer agent per file. All unit tests go in ./tests/.

Results: 43 files, about an hour, 100 dollars on Opus 4.5.

Each agent has its own 200k token context window. Understand your usage before going wide.