It has been pretty widely reported that AI can make programmers LESS productive. From my own experience, I don't 100% buy it. But I can believe that it depends partly on the individual and ESPECIALLY the tasks they're working on.

Commonly cited reasons are:

  • Corrections: fixing suboptimal AI code
  • Review Burden: more time spent on PR reviews
  • Context Mismatch: AI not grokking a large codebase or business context
  • Over-reliance: trying too hard to use AI for everything

I mostly agree? Those seem true and make sense.

I would add a few more observations from my personal projects and various things I've watched/read recently.

Productivity depends on the task

AI is great for unit testing, automation and exploration. It can generate high test coverage instantly and often has very good understanding of edge cases. AI shines when there is deterministic, testable output. For many programming tasks, this is precisely the case, but not always.

It's less good when the task is vague, under-specified, or not fully understood by the programmer running the agent. If you don't know what the right answer looks like, agentic coding is WAY less helpful and can quickly lead you astray. I found this out by trying to vibe-code a voice synthesizer, a topic which I know nothing about, and it showed.

Agentic coding reminds me of flow. A key characteristic to finding flow is that tasks need the right level of difficulty. If it's too easy or hard, a task feels boring or frustrating. Flow occurs when a task is "just right" and problem solving feels effortless. Similarly, whether a task is well-suited to agentic coding depends on how well both the programmer and the AI understand the task.

Things that.. I know lots I don't know
AI knows lots ✓ (vibing) ✓ (danger)
AI doesn't know ✓ (frequent corrections) x (waste of time)

I would bet any BIG productivity gains are coming from that first quadrant. Agentic coding can absolutely fly on tasks where both the LLM and the coder have a lot of knowledge. This is really pleasant and reminds me of "flow state".

Where things get dicey is those other three quadrants.

In niches where the AI lacks knowledge, more frequent corrections are needed. Progress is still possible here, but it's slower. Tasks require more deliberate planning and careful code review may be necessary.

The dangerous case is when the user lacks knowledge, but the AI still knows how to do what is asked (or thinks it does). This can lead to false confidence. Good results are possible, but not guaranteed. The AI can be "confidently wrong" in a way the user doesn't understand.

The final case, where both the AI and the programmer lack meaningful knowledge, is unproductive, but less dangerous. Poor outcomes are likely, but usually the results are obviously bad. With sufficient context engineering, it may be possible to move into the 3rd quandrant, but that's not necessarily a good thing.

Under-planning

AI makes it VERY easy to start a new project with minimal planning. In fact, many AIs will happily do all the planning for you. Now, for completely routine tasks with minimal scope, that can be just fine. BUT for anything complicated, the human planning phase that involves minutes, hours or days of grappling with a topic can be invaluable (and save a lot of time later on).

AI encourages the tendancy to jump straight into coding.

Over-exploration and fiddling

A closely related issue is that AI makes it almost TOO easy to experiment as a project evolves. This opens the door to several bad habits, including feature creep and over-engineering. When adding features becomes almost free, it takes some discipline to say "no" and stick within the project boundaries. AI makes it trivial to fiddle with design patterns and refactoring. This isn't a bad thing. Refactoring a so-so design can absolutely be worth it, and AI is a huge time-saver here. The problem is that temptation to KEEP tweaking forever, even after the design is good enough.

Waiting = Lost time

AI tools are fast, but complicated tasks can still take a long time to finish. It's very easy to just sit and watch the AI crunch, instead of doing something else with that newly recovered time. Partly that's a personal issue, I don't HAVE to watch the agent run, because all the work can still be reviewed at the end, either by skimming logs or diffs. Right now it's about 50-50 for me. Whether I can stop watching depends on the task. Even after months, there's still something fascinating about seeing it run in real-time.

One of the simplest fixes here, for me personally, was to create a custom Hook to play a chime when Claude had finished working. Instead of watching, I could do something else, or even walk away and wait for the chime.