AI Coding Shifts Identity from Coding to Thinking

Completely agree with Francis, who articulates how working with AI has been changing in the last few months, as he creates software. That shift is coming to most of us. This new way of working is similar to a marketer writing a very good strategic brief to an agency with context, goals, target audience, constraints, etc and then redirecting with every round, until the outcome is world-class. "The feeling isn't guilt. It's identity shift. When coding stops being the hard part, what's left is thinking clearly about what to build. Architecture. Trade-offs. Edge cases. The "why" behind every decision." "Personally, I think more in specs (business and tech) rather than prompts. Quality of prompts has a tiny impact if the specs are not clear." "You think in specifications. You articulate intent with more precision because the machine demands it."

Will AI make coding feel… quaint? I had a great chat with a coworker this week about “vibe coding” and the idea (floating around X lately) that human coding is basically over. He started reminiscing about writing software in Assembly “back in the day.” And it hit me: Assembly isn’t “dead” today, but for most of us it’s become a specialized tool, not the default. What used to take hours can now be done in minutes because the abstraction stack kept getting better. That led to a question I can’t shake: In the next few years, will manually writing code in C#, Python, Java, etc. feel the same way? Not useless, but increasingly unnecessary for the majority of day-to-day work? At the same time, we’re watching big software companies publicly talk about AI-driven productivity gains and headcount reductions. For a smaller company like ours, I think the promise is different: AI doesn’t replace our team. It lets us build like a team 10x our size. Which leads to a reframing I’ve been repeating internally: The value of a developer is shifting from “how fast can you type code” to “how well can you harness AI to create quality outcomes.” Architecture. Data modeling. Edge cases. Integration patterns. Testing. Security. Judgment. The tool changes. The job evolves. The leverage moves. Curious where others are landing on this: Is AI eliminating developers… or simply changing what great developers need to be great at?

“Vibe coding” is everywhere right now. You open an AI tool, describe what you’re trying to build, accept most of what it gives you, tweak a few things until it runs… and suddenly you’ve got a feature. It feels good. It feels fast. It feels creative. I understand the pull. There’s something genuinely fun about watching an idea turn into working software in minutes. But here’s what makes me uneasy: vibe coding doesn’t remove complexity. It just postpones it. Eventually, someone has to answer real questions: Why is the state shaped this way? Where are side effects controlled? What assumptions are we making about data? What breaks when traffic doubles? Who actually understands this system? AI can generate code. It can’t generate responsibility. And that’s the gap I keep seeing. We’re mistaking “it runs” for “it’s engineered.” There’s a difference between assembling code and designing a system. Real engineering is about boundaries, trade-offs, and thinking three moves ahead. It’s about building something that can survive change, not just demo well on Friday. If you’re hacking on a prototype or exploring an idea, vibe coding is "fine" (I guess). But when customers, revenue, security, compliance, and long-term maintenance enter the picture, vibes aren’t enough. Someone has to own the architecture. Someone has to understand the consequences. AI makes code cheaper. That doesn’t make thinking optional. The future isn’t less engineering. It’s more discernment about where speed ends and responsibility begins. Use the tools. Move fast. Experiment. Just don’t confuse momentum with mastery.

I’ve been watching the “vibe coding” debate with interest. Experienced developers are saying, loudly, that a lot of AI generated work is garbage. They’re not wrong. They’ve seen what happens when assumptions, edge cases, and operational reality are ignored. Others point out they can get something working in minutes now. They’re not wrong either. Execution has never been cheaper. The real issue isn’t skill or gatekeeping. It’s where judgment shows up in the process. AI makes execution trivial, but it doesn’t make thinking optional. It just delays the cost of poor thinking until later, when fixes are more painful and more expensive. Cheap execution creates the illusion that iteration is also cheap, but iteration compounds. Each pass introduces new assumptions, new surface area, and new drift. By the third or fourth round, you’re no longer refining. You’re negotiating with decisions you didn’t consciously make, while the system is already in motion. What’s worked better for me is moving design to the very front. I spend time clarifying intent, surfacing assumptions, stress-testing edge cases, and deciding what actually matters before asking a machine to build anything. Once that thinking is distilled into a solid prompt, I want the AI executing, not improvising. The result is fewer iterations, better first passes, and fixes that stay local instead of structural. Vibe coders get guardrails. Seasoned engineers get fewer surprises. This isn’t a new trick. It’s old engineering discipline applied to a world where execution is cheap and judgment is the scarce resource.

It's been 3 months since I switched to vibe coding, and here are my conclusions. People are in 3 camps: - Deniers: developers who say that it doesn't work for complex tasks, and it causes more problems, and future developers will rewrite the AI-generated code - Believers: people who believe that the old way of coding is dead and that all the code will be written by AI - Doomers: we will all lose our jobs As always, neither of the extremes describes the reality, but here is my experience: - Writing code with AI (Cursor) is 10 times faster. It can generate thousands of lines of code a day, which is not realistic for any developer - The code is good. Earlier LLMs often produced code that didn't compile, used classes that didn't exist, or produced nonsense. With Claude Opus, GPT5.2, Composes, or other modern LLMs the code works well - AI can think and solve complex tasks with reasoning. With the 'plan' mode in cursor it can analyse the project and suggest solutions - It helps a lot with inspecting code too. Questions like "what does this code do", "how do I use this library or function" are much more convenient to ask directly in IDE So it is true. Typing code manually doesn't make sense anymore. However: - Non-technical people cannot prompt a serious product. The person must understand what AI generates, ask for corrections, etc. Being an engineer is a type of thinking. - Engineers will be focused on solutions. They will use AI as their assistant, though, to make decisions. - AI still struggles with context. Especially when you have a multiservice setup. However, it is temporary. When it learns how to access documentation, messages, and internal systems, it may get all the context. So being a denier and saying that it's all a bubble is not a good strategy. It definitely changes the way we work. Traditional coding is dead. It is hard to say what the long-term impact is going to be. Maybe - fewer engineers. Maybe - more IT products.

The people building the most advanced coding AI on the planet don't trust it without heavy guardrails. So much for vibe coding. OpenAI published how they actually build software with AI agents. It's worth reading between the lines. "Harness engineering" - a team that shipped a 1M-line product with zero manually written code. Impressive headline. What caught my attention is what they actually had to build to make it work: - Rigid layered architecture enforced by custom linters and structural tests - 20% of engineering time initially spent cleaning "AI slop" (their words) - Recurring "garbage collection" agents fixing what other agents broke - Deliberate choice of "boring" technologies because agents model them better - A rule: if knowledge isn't in the repo, it doesn't exist To design, build, and maintain all of this - you need people who deeply understand software systems. Evaluating architecture, judging maintainability, encoding taste into tooling. That's not prompting. That's engineering experience built over years. Remember 0.92? The near-perfect correlation between sophistication of human input and AI output? (Anthropic research) This is the 0.92 at organizational scale. The input isn't a prompt - it's architecture, linters, structural tests, documentation-as-code. All built on expertise no model replaces. Knowledge was always the foundation. AI only multiplies its advantage. Source in comment.

As I continue to dig classical Multiagent research, I'm finding startling findings that are relevant to modern Vibe Coding. 1. Parasuraman's research on automation complacency (1993, 2010) found something counterintuitive: the more reliable the automation, the worse humans get at catching its errors. When a system is right 95% of the time, your brain learns to stop checking. This isn't laziness. It's a rational attention allocation strategy. Your brain optimizes for energy conservation. And it happens to experts and novices alike. Training doesn't fix it. Now look at what's happening in AI-augmented coding. Claude writes the code. A PR reviewer uses Claude to review it. QA uses Claude to write the tests. The judge, jury, and executioner are all the same model: Opus 4.6. In medicine, a study of 112 clinicians found their likelihood of accepting an alert dropped 30% with each additional alert in a session. These are trained doctors overriding life-or-death warnings. If physicians rubber-stamp clinical alerts, what chance does a developer have on their 50th Claude-generated PR of the day? The research identifies two types of errors that follow. 1. Omission errors: you fail to notice the AI missed something. 2. Commission errors: you accept a wrong AI suggestion as correct. Both increase with automation reliability. Both happen to experts. Here's the real danger for software. When a human writes code, a different human reviews it, and a third human tests it, you get adversarial diversity. Each person has different mental models, different blind spots, different experiences. That diversity catches bugs. When Claude writes the code, Claude reviews the code, and Claude tests the code, you get a monoculture. The same blind spots propagate through every checkpoint. You've effectively achieved full autonomy while pretending you have human oversight. That's the worst possible outcome: zero actual oversight with full confidence that oversight exists. Even worse, as the human written Stackoverflow and Github repos of pre-2023 vintage get drowned by AI generated advice and code in training data, we are very quickly getting to a point where the models could bring catastrophe. The vibe coders bragging about shipping at 10x speed are building exactly the system that 30 years of human factors research warns us about.

🔥 AI is changing coding. Here's the truth: Everyone's anxious. Even Kent Beck (creator of TDD) admits he doesn't know what programming will look like in 2 years. But here's what I know: → You still need to understand how computers work. If you don't know why code is slow or insecure, you can't fix what AI gets wrong. → AI writes code. You write tests. But AI can't tell you which tests actually matter. → AI doesn't know your business. It'll confidently build the wrong thing. → System design? AI sucks at it. It can write a function. It can't design a whole system. The bottom line: AI won't replace developers. It replaces people who don't understand what they're doing. If you're worried, you're paying attention. That's a feature, not a bug. Link to the article in the comment. 👇 What's your take? Drop a comment — do you think AI changes what it means to be a developer? If this resonates, repost it. Let's keep this conversation going.

Vibe coding gets a lot of heat, but it isn't the problem. Inexperienced vibe coding is. I spent hours debugging with AI last days. Here's what happened: Bug in our codebase. Two routes that look nearly identical but aren't. I gave the AI the right description of the problem, I just didn't know one small detail yet. Instead of discovering it, the AI went deeper down the rabbit hole. Fix after fix. Alternative solution after alternative solution. Never once stopped and said "hey, this actually looks correct. We've tried everything. Maybe the problem is somewhere else." A senior dev would've said that right away (and maybe I should have read the code myself, I'm just used to the AI one-shotting things now 😁) This is what separates "vibe coders" from experienced builders who vibe code: AI doesn't question your assumptions. It executes them faster. Including the wrong ones. The real skill isn't prompting. It's knowing when the AI is stuck in a loop and pulling it out. It's the architectural intuition to say "stop, we're looking in the wrong place." After 20 years of building tech I can tell you, the best developers weren't the ones who wrote the most code. They were the ones who knew which problem to solve. AI doesn't change that. It amplifies it. That's 20 years of building talking. Not 20 days of Cursor. Photo by Filipe Delgado