Agent-heavy work eventually comes back to the human side of software practice.
Not "which model wins?" and not "will developers matter?" The useful question is smaller: when agents can write more code, what do people still need to judge, critique, own, and verify?
Judgment Stays Human
For product software, the durable skill is judgment:
- understand the user
- critique the experience
- communicate clearly
- decide where agents help
- decide where agents hurt
- keep control of the tools
- verify the result
The point is not to replace technical ability with taste. The point is to connect technical work to product reality.
Interview With A Product Flow
A useful interview exercise can be simple:
I would open up a website and just have someone critique it. Have them go through a few websites, have them click around. And not even find bugs, just find what they think could improve from the user experience.
— John Lindquist
Open a real website or app. Ask the candidate to click through one flow, describe who the product serves, critique the experience, and connect that critique back to engineering decisions.
Then add the agent layer:
- Where could an agent improve this experience?
- Where could an agent make it worse?
- What should remain human-reviewed?
- What would you ask an agent to do first?
- How would you phrase the prompt so the work stays bounded?
Traits to look for:
| Trait | What To Look For |
|---|---|
| Product judgment | Can they tell what the product is for? |
| Communication | Can they explain the critique clearly? |
| Critique quality | Can they identify tradeoffs without just dunking on the UI? |
| User understanding | Can they connect features to user needs? |
| Agent judgment | Can they name where agents improve or damage the workflow? |
| Prompt framing | Can they turn critique into bounded agent work? |
Speculation Is Not A Roadmap
Near-term AI predictions should read as speculation.
Cheaper access to capable open models may reduce the need for some hand-built skills, video pipelines, and helper scripts. Agents may get better at noticing repeated work and creating small tools from the flow of a project.
Maybe.
That is a direction to watch, not a roadmap commitment.
Memory and tool self-improvement are moving targets. Teams are still figuring out how agents should remember past conversations, project state, repeated tool needs, and decisions that should shape future work.
Do not present current model-roadmap, pricing, capability, or provider behavior claims as fact unless they are freshly verified.
Fatigue Is About Control
AI fatigue grows when AI feels forced, opaque, or outside the user's control.
People generally get frustrated with AI when it's forced upon them, and when it's something that they haven't made themselves. And they don't feel like they have control over it.
— John Lindquist
The answer is not "use more AI." The better answer is agency:
- adapt the tool
- own the loop
- inspect the result
- measure whether it helped
- keep review points visible
- make automation opt-in where the decision matters
Software examples:
- A checkout team adds a tiny local wrapper that always loads failing test output before asking an agent to patch.
- A billing team builds a review command that compares webhook strategies and requires proof commands.
- An auth/session team adds a project-local checklist before letting an agent touch token rotation.
- A UI team turns repeated design critique into a decision surface instead of asking the same chat prompt every day.
Local tools can change the feeling of the work because the developer can adapt the loop and see whether the change actually helped.
Ethics Boundary
Ethical concerns around AI are real and should not be waved away.
A practical workflow does not need to settle training data, copyright, compensation, platform power, or labor questions. It does need to avoid pretending those concerns do not exist.
The practical workflow boundary is smaller:
- review what goes into the tool
- keep private material private
- preserve human choice
- make review points visible
- do not make automation mandatory by default
- leave room for people to say no
This does not solve the broader ethical questions. It keeps the local workflow honest.
Copyable Artifact: Product Judgment Interview Packet
Candidate exercise:
- Open a real website or app.
- Click through one user flow.
- Explain who the product appears to serve.
- Name what the flow is trying to help the user accomplish.
Critique:
- What works?
- What is confusing?
- What user need is underserved?
- What engineering choice might be causing the friction?
- What evidence would you inspect before changing it?
Agent fit:
- Where could an agent improve the experience?
- Where could an agent make it worse?
- What should remain human-reviewed?
- What should the agent not infer?
Prompt:
- Ask the candidate to write the first agent prompt.
- Require scope, files or surfaces to inspect, constraints, proof, and stop condition.
Evaluation:
- Product judgment:
- Communication:
- Critique quality:
- User understanding:
- Agent boundary judgment:
- Prompt clarity:
Close The Loop
The useful follow-up is concrete:
- segmented recording
- reference links
- setup notes
- open questions
- verification gaps
- next actions
Do not end with a prediction cloud. End with the materials needed to keep working.
Claim Boundaries
Avoid broad labor-market claims. Avoid exact model labels, provider claims, price claims, memory-system claims, or capability predictions unless freshly verified.
Keep the final message narrower and stronger: judgment, agency, review boundaries, and measurable software work still matter.