For the past few months I've been playing around with various AI assisted coding tools. So far, Cursor seems to be the tool with the most usage/ mindshare, and it has been my daily driver for the most part. Recently however, Cursor made some interesting pricing choices that have disgruntled their userbaseIt doesn't help that programmers are infamously easy to disgrunt. As such, there's been a lot of chatter amongst the vibe-coding cognoscenti as to alternatives. One such alternative which has come up relatively consistently is Anthropic's Claude Code. At first this was unsurprising, since I've always found Anthropic's models to be superior to the other foundational model providers when it comes to coding. Interestingly though, the general reception to Claude Code has been quite polarizing, with one camp singing its praises and treating it as the second coming, and the other quickly becoming apostates, trying it a few times and then proclaiming that it just "isn't as good", and doesn't seem to "get it" (and then disheartendly slinking back to Cursor).
This dynamic is particularly interesting because most of the people I've talked to who dislike Claude Code are regular users of Cursor and other LLM tooling, so they are familiar with how these tools theoretically work. I also know them to form intelligent opinions in generalas opposed to the typical rabid genuflection at the alter of the latest LLM tooling by the general mass of AI-pilled "devs" on twitter, and so was surprised that their experience differs from my own successful/ enjoyable usage of Claude Code. I'm on vacation, and so have had more time than usual to ruminate on things, and I think I've figured out what the disconnect here is.
Copilots vs Coworkers
The core issue at hand, and why some devs are struggling to adopt tools like Claude Code is unrelated to the tool itself, and instead due to a mental model discrepancy. Fundamentally, Cursor saw its meteoric rise in adoption because it packaged up the power of LLM assisted coding into a UX that was already familiar to developers. They took an IDE and supercharged it. Sure, they have since added more agentic workflows, and recently background agents, but what made their bones was that they started with a coding tool devs were already comfortable with (autocomplete in an IDE), and sprinkled in some magic. As Cursor has continued to evolve, the paradigm has shifted towards devs "coding" in english, and it acting as a UI to transcribe that english into a computer language, but the primitives have remained the same... You see the diff of code changes, iterate on it as necessary, and are always in control of the process at a very granular level.
If you've become comfortable with that way of operating, and are patting yourself on the back for really being on the ball with this whole AI thing, then using Claude Code can feel like a regression. That's because Claude Code is an instantiation of a truly "agentic coding" tool. Whereas Cursor fits the paradigm devs have used since the advent of IDEs, Claude Code (and other agentic coding tools) requires a mental model shift wherein you act as a manager responsible for an eager and smart, but sort of clueless junior dev. People that don't grok this difference will struggle to use Claude Code for the same reason that managers who don't know how to manage end up tanking team efficiency. Given the aversion a lot of devs I know have to management in general, it isn't surprising that crossing this chasm has been met with resistance. Regardless, agentic tooling is the future, so there's no choice but to get on board. The rest of this post is my attempt at a guide for how to do so.
From Micromanager to Tech Lead
It is a somewhat well established leadership doctrine that "micromanaging" your employees is bad. Instead, you want to hire smart people, and develop them such that they are capable of delivering the right things for your business without constant oversight. This doctrine applies equally to the world of agentic coding. The way people use Cursor, meticulously correcting diffs chunk by chunk, and iterating back and forth via the prompt sidebar is akin to micromanaging a new hire by grabbing their keyboard every few seconds to fix their code. You're catching the metaphorical fish for them instead of teaching. It's inefficient and frustrating for you, and doesn't leverage (or let them reach) their full potential.
Instead, think about how an experienced tech lead teaches a junior dev. When a junior puts up a PR with issues, the tech lead doesn't just pull the branch, fix the code, and push it. That would solve the immediate problem, but practically guarantee that the junior will make the same mistake again. Instead, a great tech lead spends time explaining the underlying principle behind the required changes, touches on relevant best practices and architectural patterns where appropriate, and links to useful documentation, blog posts, etc. All of this is more work in the moment, but provides useful context that the junior can learn from in a more sustainable fashion, and levels them up over time.
This is precisely how we must interact with coding agents. With Claude Code, for example, it means that you stop touching the code it produces directly, and start teaching it how to write better code. Let that sink in: Don't manually edit the diffs. The core of this new workflow can be thought of as "context engineering"which is something of a buzzword at this point, similar to "prompt engineering", but the underlying concept is key to getting good performance out of the models. You need to give your AI agent the same onboarding packet you'd give a new employee. In Claude Code, this can be managed through files like claude.md, and Anthropic already provides mechanisms to scope the context as desired. Furthermore, you must iterate on this context over time, teaching claude how to level up into the type of engineer you/ your company wants.
Most devs that have embraced AI for coding know this abstractly, but haven't fully internalized it into their workflow. Instead of me trying to reinforce that learning, here's a few shots at examples that hopefully put things in context:
Example 1:
- DON'T: See that the agent used a magic string instead of a constant, so you edit the diff to fix it.
- DO: Leave a code-review style comment to Claude Code like: "Please refactor this to use the defined constants from
constants.tsto avoid magic strings. Then, ensure yourclaude.mdfile has a rule explicitly stating:Rule: Always use predefined constants for configuration values and event names. Avoid using raw strings ('magic strings') directly in the code."
Example 2:
- DON'T: Manually fix a poorly formatted block of code.
- DO: Give feedback like: "This doesn't seem to follow our project's linting rules. Please run the linter and apply the necessary fixes. Then, update your context file to contain instructions on how to run and respect those tools such as:
All code must pass the ESLint check before being considered complete. Run 'pnpm run lint' and fix all errors."
Example 3:
- DON'T: Move code the agent has implemented to a different spot or change the names and/or structure of things it creates.
- DO: Give feedback that clarifies why the names or structure of the code written doesn't align with your expectations, and what general rules or heuristics are applicable to ensure that sort of mistake doesn't happen again. Tell Claude Code to reiterate the learning back to you, and then add a rule to the
claude.mdfile when you're satisfied with its understanding.
This is the proper agentic loop. When the agent gets it wrong, you don't fix the output; you clarify the instructions and improve the context. Then you ask it to try again. Trying again- instead of fixing almost working code- feels strange for devs used to treating code as a scarce good, but code is a commodity now, and our new AI coworkers never get tired, bored, or annoyed at being asked to redo a task.
Compounding Returns
Again, this slows things down at first, because teaching is harder than doing. What you learn as a tech lead, though, is that the benefits of scaling a dev team in this way very soon outweigh the cost of the initial slowdown. Add in the fact that LLMs don't need health insurance or vacations, and their brains operate in gigahertz, and the true return on investment starts to come into focus. With a human developer, this mentorship pays off over months and years. With an LLM agent, the iteration cycle is measured in minutes. After you add a rule to your context file, the agent learns it for the very next task. The quality of its output doesn't just get better; it stays better. You stop having to correct the same class of errors over and over again. Now, every time you improve the agent context, you are improving every single future junior dev. Additionally, scaling your team switches from being bottlenecked on hiring to being bottlenecked on compute.
You can't clone your best senior developer who has spent five years internalizing your company's culture and codebase. But you can clone a well-mentored AI agent's configuration instantly. Once you have crafted a high quality context that produces idiomatic, compliant code, you can spin up ten or a hundred copies of that agent, limited only by your budget. You can build a scalable, effective development team that grows with your needs.
Your Next Promotion is to "Agent Manager"
To recap:
- A Paradigm Shift is Here: The turmoil in the AI coding tool space is accelerating a necessary shift from "copilot" models (better autocomplete) to "agentic" models (digital coworkers).
- Stop Micromanaging, Start Managing: Success with tools like Claude Code hinges on changing your mindset. Stop editing diffs directly and start providing high-level, code-review-style feedback.
- Context is King: Your primary job becomes "context engineering." Build and maintain a comprehensive set of instructions, rules, and best practices that your AI agent can use as its source of truth.
- Embrace the Loop: The workflow is: Task -> Review -> Feedback -> Update Context -> Retry. This creates a compounding effect where the agent's capabilities continuously improve.
- The Future is Scalable: Mastering this agentic workflow isn't just about using a new tool effectively; it's about learning a skill that will define the next generation of software development- the ability to manage and scale a team of AI developers.
The developers who are lamenting that tools like Claude Code "aren't as good" to use are likely actually running into gaps in their ability to teach. Cursor, and other IDE based AI tools were easy to adopt because they provide escape valves to cover up that teaching deficiency, but the future of AI assisted coding is increasingly autonomous agents, and micromanaging them won't scale for all the same reasons that micromanaging humans doesn't scale.
This will be a hard pill for some software developers to swallow. Until recently I wrote software used regularly by pharmacists, and so found this Steve Yegge quote particularly pertinent to the situation:
Pharmacists have told me that a lot of patients are confused about their suppository meds and try to eat them. I think that is such a beautiful metaphor here. [Agentic coding] is unintuitive, biased towards hotshots, nonuniform in its productivity boosts, not yet well-supported by tools, and hard to measure. And you shouldn't eat it.
It's up to you to decide what you should do with it to ensure you're maximizing its value.