Getting started with AI agents

Priming the Pump

Start with an engineering conversation, not a perfect prompt.

Contents
  1. The skeptic who called me
  2. The real barrier
  3. What priming the pump means
  4. What it looks like
  5. How far to go
  6. How you know it’s primed
  7. Where it leads
  8. Is it really that simple?
  9. Try it

The skeptic who called me

One of the biggest AI skeptics at my company called me one day. “I tried it and it didn’t work for me,” he said. “I see you doing it, and I don’t believe what I’m seeing. Show me how you do it.”

So we paired. I asked what he was working on and had him open Claude Code in that project’s folder. I told him I don’t use big prompts; I just talk to it like I would anyone else. Then I explained how I “prime the pump” and fed him a few plain questions to ask it. He caught on right away.

He went on to become one of the best AI engineers at the company, and he started helping others get going. His skill hadn’t changed. What changed was how he started the conversation.

The real barrier

The barrier usually isn’t the AI. It’s the belief that you have to write an elaborate prompt, or a full spec, before you’ll get anything useful.

So people either spend an hour crafting the perfect prompt, or they type a one-liner, get something generic back, and decide AI doesn’t work. Both start in the wrong place.

I use plain, almost naive questions that anyone can ask. No prompt engineering and no spec. It’s the approach I use in my own work and the first thing I show teammates who are getting started.

What priming the pump means

An old hand pump won’t draw water from a dry start.

You pour a little water in first, and then it flows.

Working with an AI agent is the same. Instead of a perfect prompt, I start an engineering conversation: I ask about the existing system, clarify requirements, and talk through constraints. The agent asks questions too. It’s very much like a conversation with another engineer: the same questions you’d ask a teammate while you look at the code together. Each round points more clearly at the target.

Then I say “go,” and the go always names its target: “implement what we just discussed,” not just “go.” The agent implements, tests, and verifies the work, and comes back with questions when it needs to.

The principles are simple:

  1. Conversation builds the context the environment doesn’t already have, in both directions.
  2. The effort grows with the scope of the work.
  3. “Go” always names its target.
  4. Engineering judgment sets the direction. Agents propose the implementation, and review decides.
  5. Working, verified software is what counts.

What it looks like

This is the kind of conversation I had my colleague start, with the agent open in his project folder. The details are illustrative, but the shape is real:

  1. “What is this project?”Get oriented.
  2. “How do scans get into the system?”Trace the path that matters.
  3. “Does that include zip files?”Probe the gap.
  4. “What needs to happen to make it include zip files?”Let the agent find the work.
  5. “What’s the best way to receive those if the files are large?”Bring in a constraint.
  6. “What needs to change in the scanner project to do that?”Narrow to the target.
  7. “Go ahead and make those changes to the scanner, and test them end to end.”Go, with a named target.

None of these questions is clever. They’re what you’d ask another engineer who knows the project. Each answer sets up the next question, and by the time you say go, the agent has read the code itself. It knows the system, the gap, the constraint, and the target, and you never wrote a prompt.

How far to go

Prime only as much as the work needs. I often build iteratively, each round of conversation sharpening the target, and the size of the work decides where the conversation ends up:

ScopeThe conversationWhat it produces
A taskA few questions, like the example aboveEnough shared understanding to do that one thing
A featureA longer discussion of requirements and designTickets the agents can work from
An initiativeA larger discussion, over several sessions if neededA document that outlasts any one session

Writing it down matters as the work grows. An agent’s memory of a long session gets compressed and details are lost, so a larger discussion ends up as a document or tickets the agent can always go back to. Prompt engineering spends heavy effort on everything, and spec-driven development writes a spec for everything. Priming the pump spends effort in proportion to the work.

A good ticket is a pump someone already primed

When one exists, priming can be a single question. Once I asked my agent to “look for any tickets regarding ingestion pipeline,” then “which should we start with?” and “yes, do both.” About 35 words from me later, a PR was posted on the ticket with the fix, before-and-after results for the ticket’s three examples, and test and benchmark results, and all five review comments had been addressed. The ticket primed the problem; the fleet’s accumulated rules primed the process. The solution was in neither. My part was choosing the work and reviewing the result.

Why so little from me? Most of the context was already there: the code the agent reads, the tickets, the guidance and rules the fleet has collected from earlier work, its memory, and a running system to check its work against. The conversation only has to supply what’s missing: the gap and the target. The more the environment holds, the lighter the priming can be.

How you know it’s primed

A simple check before you say go: ask the agent to tell you what it’s about to do and why. If its answer matches what you have in mind, it’s primed. If it doesn’t, keep talking.

The agent’s own questions are a good sign too. When it asks about something you hadn’t thought of, the conversation is doing its job: catching a misunderstanding before any code is written, not after.

The same habit helps when you come back to a session later. “What are we working on? What’s next?” tells you what the agent still remembers before you rely on it.

Where it leads

The same approach scales from one agent to a team of them. I prime the pump with my terminal agent, it decides how to split the work, and managers coordinate developer agents, each working in its own complete, running copy of the system. They return integrated, verified pull requests for review.

The start never changes: a conversation, then a go with a named target. I describe the rest in The Agent Drives, I Navigate.

Is it really that simple?

When I look back at what I ask the agent, I think almost anyone could do this. The questions are that plain.

But anyone can ask those questions, and not everyone would ask those particular ones. “Does that include zip files?” only sounds naive once someone has thought of it. Spotting that gap, bringing in the large-file constraint, and knowing when the agent’s understanding matches mine all come from engineering experience. So does noticing when its work is wrong.

So anyone can start this way, and the conversation teaches you as you go. Experience is what turns plain questions into the right ones. My skeptical colleague was already an experienced engineer, which is probably why he caught on so fast. He wasn’t missing the skill, just permission to talk to the agent normally.

Try it

  1. Pick one small task you’re actually working on.
  2. Open your agent in that project’s folder.
  3. Ask plain questions until the agent understands the system, the gap, and the target.
  4. Say go, and name the target.
  5. Check the result in the running system, not just the tests.

Feel free to ask anything along the way. For me, worrying about cost was what held me back most. Once I switched to open-weight models, I felt free to ask for anything, even though they were sometimes less capable, and that freedom was good for learning. If you’re learning, a low-cost subscription such as OpenCode Go (about $10 a month) with an agent like Pi goes a long way. Right now I’d use glm-5.3-flash with it. Prices and models change quickly, so check what’s current.

Don’t spend your time building perfect prompts.

Build shared understanding through engineering conversation, as much as the work needs, then delegate and verify.