Getting started with AI agents
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
It’s the belief that you need an elaborate prompt, or a full spec, before you’ll get anything useful.
Too much
Heavy effort up front, before the agent has looked at a single line of code.
Too little
Something generic comes back, and the conclusion is “AI doesn’t work.”
Both start in the wrong place.
The metaphor
You pour a little water in first, and then it flows. Working with an AI agent is the same.
What priming the pump means
Ask
The questions you’d ask a teammate while looking at the code together.
→
Clarify
The agent asks questions too. Context builds in both directions.
→
Constrain
Each round points more clearly at the target.
→
Go
Never just “go.”
→
Agent
And comes back with questions when it needs to.
It’s very much like a conversation with another engineer.
The principles
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
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
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
02
03
04
And you never wrote a prompt.
How far to go
| Scope | The conversation | What it produces |
|---|---|---|
| A task | A few questions, like the example | Enough shared understanding to do that one thing |
| A feature | A longer discussion of requirements and design | Tickets the agents can work from |
| An initiative | A larger discussion, over several sessions if needed | A 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
~35
words from me, across three short messages
“Look for any tickets regarding ingestion pipeline.” “Which should we start with?” “Yes, do both.”
How you know it’s primed
Before go
If it matches what you have in mind, it’s primed. If not, keep talking.
During
It raises something you hadn’t thought of, catching a misunderstanding before any code is written.
Coming back
Find out what the agent still remembers before you rely on it.
Where it leads
Prime
A conversation, then a go with a named target.
→
Split
Decides how to divide the work.
→
Coordinate
Run developer agents.
→
Build
Each in its own complete, running copy of the system.
→
Return
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
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.
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.