How do you like to work with AI coding agents?
There seems to have two types of developers:
Human in the loop: Those who like to control the behavior of their agents as it works, looking at the context usage, reading reasoning blocks, and approving individual file edits.
Agent first: Those who prefer to review the output of agents, rather than individual actions, and run one or more sessions in parallel.
What type of developer are you when working with AI coding agents?
For context, when @Kilo Code launched their new @VS Code extension last week, with parallel agents, inline diff reviewer, and multi-model comparisons, some users actually wanted more control back.
While the team is working on multiple improvements, like better diffs before you approve and permission flow fixes, I'm curious about your point of view.
How do you like to work with AI coding agents?
Replies
@fmerian Agent-first has been useful for testing ideas faster, but I like checking results afterward to avoid mistakes.
Tabstack
interesting! fun fact: when @Kilo Code launched their new @VS Code extension last week with inline diffs, it initially showed diffs after approval. Early users made it clear many desire to review changes before committing to them.
there's definitely a balance to find between building fast and building right.
@fmerian that's the main reason why I was using Claude Code inside VSCode - I was able to make live changes in the diff before approving it. I recently switched (back) to neovim and I'm kinda missing this feature, but it's not a showstopper to me
Feels like there’s a spectrum rather than two categories. I still prefer human-in-the-loop for architecture or reasoning-heavy tasks, but for repetitive workflows I’m increasingly comfortable letting agents run more autonomously.
Around Turgo workflows, the biggest factor has been reliability and predictability. Once an agent behaves consistently, supervision naturally decreases.
Earth.fm
Nice prompt — this is exactly the kind of question shaping how we’ll work in the next few years.
For me, the best way to use AI coding agents is as “collaborative engineers, not autocomplete tools.”
I usually split work like this:
I let the agent handle boilerplate, refactors, debugging, and exploring alternatives, while I focus on architecture decisions, constraints, and final review. The biggest productivity jump comes when you treat the agent like a junior dev that can execute fast but still needs direction and validation.
Also, iterative feedback loops work way better than one-shot prompts — small tasks, quick checks, then expand.
Tabstack
@1mirul spot on! FYI see this thread on prompt engineering best practices. [1] contributions highlight the importance of a spec-driven approach, starting with the expected outcomes then breaking down step-by-step the different dependencies.
[1]: What's your prompt engineering workflow?
definitely agent-first, i want to be less and less in the loop
Tabstack
@fberrez1 interesting! fun fact: when @Kilo Code launched their new @VS Code extension with parallel agents last week, some users actually wanted more control back (read: visibility), i.e. seeing the agents' thinking and better diffs before approval.
curious what's your level of permissions? the more, the better?
@fmerian I have my machine with no personal stuff on it, my agents run with all permissions allowed on it.
Tabstack
@fberrez1 human machine 🦾
I use Claude Code heavily, both at work and for personal projects, but I always read through and review the code it produces. The main issue I've noticed with AI-generated code is scaling. It often writes code that scales poorly, or starts off performant but loses the thread after a few rounds of redesign, with sloppy updates creeping in. Data structure choices can also be questionable at times.
Tabstack
@prad1 as pointed out in this thread, some people might feel too "zoomed out" from the work using a terminal like @Claude Code, while an editor-first UI could feel like a misfit when the majority of code is written by agents.
what's your setup?
@fmerian I mostly use the CLI since it's convenient to run directly on a repository. After Claude finishes updating the code, I use GitKraken to review all the changes, and if something needs closer scrutiny, I open Rider or whichever IDE fits the language. Most IDEs come with AI plugins and extensions these days, but I still prefer the terminal.
I’m leaning toward a hybrid setup: human-in-the-loop for architecture, risky edits, and anything that changes core behavior — agent-first for implementation, refactors, and well-scoped tasks.
The sweet spot for me is giving the agent enough autonomy to move fast, then reviewing the final diff and reasoning at the decision points rather than micromanaging every file edit. feels like where coding workflows are heading. 👀
Tabstack
@alpertayfurr feels like a solid balance - love it
@fmerian Thanks! Yeah, I think the main unlock is not just “more autonomy,” but better checkpoints. If the agent can move fast while keeping the reasoning and diffs easy to review, the workflow feels much safer.
If I were just doing some conceptual and creative work, perhaps I would like Agent First. I enjoy the feeling of watching it work in multiple parallel lines and then presenting me with all the results for me to review. But if my job involves designing important product adjustments, I would prefer to be part of the loop. I would worry that the AI might make a mistake somewhere and have a significant impact on me.
Human in the loop 100%
But mostly for my benefits, as I'd like to learn as a PM how things are actually implemented :))
I'm more of a hybrid, but I lean more toward a human-in-the-loop approach.
Powabase
For certain processes, it's critical to include human judgement.