Agentic coding is Reminiscent of REPLs
The following is an AI generated summary of the video
Agentic Coding Feels a Lot Like a REPL
Like many developers, I've been experimenting with agentic coding recently. While the technology itself is impressive, what struck me most wasn't the AI—it was how familiar the workflow felt.
The closest comparison I can think of is working with a REPL (Read-Evaluate-Print Loop).
From Coding to Directing
Traditional software development involves writing code directly. You think through a problem, implement a solution, run it, and evaluate the result.
Agentic coding follows a surprisingly similar pattern.
Instead of writing code yourself, you describe what you want. The AI plans the work, generates code, applies changes, and presents the result. You then evaluate it, refine the requirements, and repeat the cycle.
The loop becomes:
- Describe an idea.
- Let the AI implement it.
- Evaluate the result.
- Refine and iterate.
It's still software development, but you're operating at a higher level of abstraction.
Building a Real Project
To explore this workflow, I built a MIDI patch editor for a collection of hardware synthesizers.
The application allows me to:
- Connect to MIDI devices.
- Create and save synthesizer patches.
- Export and import patches as YAML.
- Apply software-driven LFOs to hardware parameters.
- Randomise patches on supported synths.
- Define synthesizer controls using a simple configuration language.
The result is a genuinely useful piece of software that grew from a series of conversations and instructions rather than thousands of lines of manually written code.
While I contributed ideas, testing, and direction, the vast majority of the implementation was generated by AI.
The New Skill Is Evaluation
One thing agentic coding makes clear is that software development is becoming less about typing code and more about evaluating solutions.
The AI can generate code quickly, but it still requires supervision.
Someone has to decide:
- Whether the feature solves the problem.
- Whether the implementation makes sense.
- Whether the generated code is maintainable.
- Whether the trade-offs are acceptable.
The bottleneck is no longer typing speed. The bottleneck is judgement.
This creates an interesting challenge for newer developers. If AI writes most of the code, how do people develop the experience needed to evaluate that code effectively?
That's a question the industry hasn't fully answered yet.
Ideas Become Software Faster
The biggest advantage of agentic coding is speed.
Projects that might previously have taken days or weeks can often be turned into working prototypes in a matter of hours.
For hobby projects and experiments, this is transformative.
Rather than spending a weekend building infrastructure, you can spend a weekend exploring ideas.
The gap between concept and implementation becomes dramatically smaller.
The Hidden Cost
Agentic coding isn't free.
Every feature request consumes resources, whether that's developer time, AI credits, or both.
In many ways, working with an AI agent feels similar to working with a junior developer. Poorly specified requirements lead to poor outcomes. Unnecessary features waste time and effort.
The better you understand what you're trying to build, the better results you'll get.
The technology rewards clarity of thought.
A Shift in Perspective
What I find most challenging isn't the technology itself but the change in role.
For many engineers, writing software has always been part of their identity. There is genuine satisfaction in crafting a solution by hand and seeing it come together.
Agentic coding changes that relationship.
You're less of a builder and more of a designer, reviewer, and director. The creative process remains, but the mechanics are different.
That shift can feel uncomfortable, even when the productivity gains are undeniable.
Final Thoughts
Agentic coding isn't replacing software engineering. It's changing where engineers add value.
The ability to write code still matters, but increasingly the critical skills are understanding requirements, evaluating solutions, making trade-offs, and guiding implementation.
In that sense, the future may look less like traditional programming and more like an endless REPL loop: describe, evaluate, refine, repeat.
The tools have changed, but the underlying process feels surprisingly familiar.