Getting started with AI agents

Priming the Pump

Start with an engineering conversation, not a perfect prompt.

The skeptic who called me

“I tried it and it didn’t work for me. I see you doing it, and I don’t believe what I’m seeing. Show me how you do it.”

We paired

Claude Code open in his project’s folder. No big prompts: talk to it like you would anyone else.

Plain questions

I fed him a few plain questions to ask it. He caught on right away.

What changed

Not his skill. Only how he started the conversation. He went on to help others get going.

The real barrier

The barrier usually isn’t the AI

It’s the belief that you need an elaborate prompt, or a full spec, before you’ll get anything useful.

Too much

An hour on the perfect prompt

Heavy effort up front, before the agent has looked at a single line of code.

Too little

A one-liner

Something generic comes back, and the conclusion is “AI doesn’t work.”

Both start in the wrong place.

The metaphor

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.

What priming the pump means

A conversation, then a go with a named target

Ask

The existing system

The questions you’d ask a teammate while looking at the code together.

→

Clarify

Requirements

The agent asks questions too. Context builds in both directions.

→

Constrain

Talk through limits

Each round points more clearly at the target.

→

Go

“Implement what we just discussed”

Never just “go.”

→

Agent

Implements, tests, verifies

And comes back with questions when it needs to.

It’s very much like a conversation with another engineer.

The principles

Five simple rules

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; review decides.

5

Working, verified software is what counts.

What it looks like

Seven plain questions

01

“What is this project?”

Get oriented

02

“How do scans get into the system?”

Trace the path that matters

03

“Does that include zip files?”

Probe the gap

04

“What needs to happen to make it include zip files?”

Let the agent find the work

05

“What’s the best way to receive those if the files are large?”

Bring in a constraint

06

“What needs to change in the scanner project to do that?”

Narrow to the target

07

“Go ahead and make those changes to the scanner, and test them end to end.”

Go, with a named target

Why it works

None of these questions is clever

They’re what you’d ask another engineer who knows the project. By the time you say go, the agent has read the code itself and knows:

01

The system

02

The gap

03

The constraint

04

The target

And you never wrote a prompt.

How far to go

Prime only as much as the work needs

ScopeThe conversationWhat it produces
A taskA few questions, like the exampleEnough 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

Prompt engineering spends heavy effort on everything; spec-driven development writes a spec for everything. Priming spends effort in proportion to the work.

A good ticket is a pump someone already primed

When the ticket exists, priming can be one question

~35

words from me, across three short messages

“Look for any tickets regarding ingestion pipeline.” “Which should we start with?” “Yes, do both.”

  • A PR posted on the ticket with the fix
  • Before-and-after results for the ticket’s three examples
  • Test and benchmark results
  • All five review comments addressed

How you know it’s primed

Check before you say go

Before go

“Tell me what you’re about to do and why.”

If it matches what you have in mind, it’s primed. If not, keep talking.

During

The agent asks good questions

It raises something you hadn’t thought of, catching a misunderstanding before any code is written.

Coming back

“What are we working on? What’s next?”

Find out what the agent still remembers before you rely on it.

Where it leads

The same start scales to a team of agents

Prime

Me and my terminal agent

A conversation, then a go with a named target.

→

Split

Terminal agent

Decides how to divide the work.

→

Coordinate

Managers

Run developer agents.

→

Build

Developer agents

Each in its own complete, running copy of the system.

→

Return

Verified PRs

Integrated and ready for review.

The start never changes. The rest is in “The Agent Drives, I Navigate.”

Is it really that simple?

“Does that include zip files?” only sounds naive once someone has thought of it.

Anyone can

Ask plain questions. The conversation teaches you as you go.

Experience does

Spot the gap, bring in the constraint, know when the agent’s understanding matches yours, and notice when its work is wrong.

The skeptic

Wasn’t missing the skill, just permission to talk to the agent normally.

Try it

Five steps, starting today

01

Pick one small task you’re actually working on.

02

Open your agent in that project’s folder.

03

Ask plain questions until it understands the system, the gap and the target.

04

Say go, and name the target.

05

Check the result in the running system, not just the tests.

Don’t spend your time building perfect prompts.

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

© 2026 Joseph Cava. Licensed under CC BY 4.0.

Speaker notes
Article