App Coding in 2026: I Don't Know What I'm Doing Anymore (And That's Fine)
Posted on
I've been writing software for about twelve years. I remember the arguments about semicolons. I remember when "mobile-first" was a hot take. I remember manually setting up webpack configs and feeling like I'd summoned a demon from a YAML file.
None of that prepared me for what coding actually looks like today.
The Vibe Shift Nobody Warned You About
Here's the honest truth: I no longer write most of my boilerplate. I haven't in about two years. My AI pair-programmer writes the scaffold, I write the intent, and somewhere in the middle we argue about naming conventions like an old married couple. The weird part is — it works. Like, embarrassingly well.
But calling it "AI-assisted development" still feels like calling a calculator a math assistant. What's actually happening is closer to collaborative authoring. I describe a system. The model proposes a structure. I push back on the architecture. It refactors. I test. We iterate. The distinction between "my code" and "generated code" has become genuinely philosophical, and most days I don't have the bandwidth to care.
What I do care about is: does this ship? Does it hold up under load? Is the logic correct? Those questions are still mine. They'll always be mine.
The Stack in 2026 Is Weird and I Love It
I'm currently building a mobile app. Here's what that actually looks like.
The core logic lives in TypeScript. Not because I have particularly strong feelings about TypeScript — I used to — but because every tool in the chain speaks it fluently, and fighting that is a fool's errand. The AI tooling, the LSP integrations, the test runners: they all want TypeScript, and at some point you stop swimming upstream.
The UI layer has gone mostly declarative in ways that would have seemed radical four years ago. I'm not manually managing state the way I used to. Reactivity has gotten so good that I sometimes forget I'm writing frontend code at all. It feels more like authoring a document that happens to respond to events.
Backend is where things get interesting. Serverless edge functions have eaten so much of what used to be "just write a Node server." I haven't provisioned a VM for a side project in over a year. The infra is configuration at this point — a few dozen lines of TOML and you have a globally distributed API with zero cold start times and a bill that rounds to zero unless you actually get traction. It's almost suspicious.
The Part Where I Talk About AI Tools Honestly
I use Claude to code. I also use it to rubber duck. I also use it to write commit messages when I'm too tired to be articulate, and to draft the error messages in my UI, and occasionally to talk me out of bad architectural decisions at 11pm when I should be sleeping.
The models are genuinely good now in a way that is hard to overstate if you haven't been watching closely. They understand context across large codebases. They catch logic errors I skip over because my brain autocorrects them. They suggest refactors that I didn't ask for and are usually right.
But they hallucinate API shapes. They confidently reach for library versions that don't exist. They sometimes produce code that looks correct, compiles, runs, and is subtly broken in ways that only surface under specific conditions. That last one is the dangerous one.
The skill that has become most valuable in 2026 is not "can you write code." It's "can you read code critically." Every senior engineer I respect right now has the same superpower: they can look at a block of generated output and immediately feel where the wrongness is hiding, even before they can articulate why. That instinct is not automatable yet. It is, weirdly, more valuable now than it was when writing every line yourself was the default.
Testing Has Had a Renaissance
I used to hate writing tests. I still sort of hate writing tests. But the tooling has gotten so good that my hatred has mellowed into a grudging respect.
Test generation is mostly solved if your code is well-structured. You describe the behavior, the model writes the cases, you add the edge cases you know from experience, and you end up with coverage that would have taken me an afternoon two years ago. It takes twenty minutes now. Most of that time is me second-guessing whether a particular edge case is actually worth covering or whether I'm procrastinating on the real work.
The shift is that testing now happens earlier, which sounds obvious but for a long time was just aspirational talk. When it's this cheap to write a test, you write it before you write the implementation. And then something interesting happens: the implementation gets better because the test forced you to think about the interface first. Ancient wisdom. Finally actually practiced.
Deployment Is a Non-Event
I want to say something that I couldn't have said three years ago without laughing: deploying an app is boring now. Good boring. Appropriately boring.
Push to main. Pipeline runs. Preview URL lands in the PR comments. Green checks. Merge. Production update in ninety seconds. Rollback is one command.
I've been in this industry long enough to remember when a deployment was an event. You picked a low-traffic window. You had a rollback plan. You told someone on call to be ready. None of that drama exists in my workflow anymore for anything short of a database migration, and even those are significantly less terrifying than they used to be.
The infrastructure complexity hasn't gone away. It's been abstracted behind platforms that have eaten the operational pain on your behalf. Whether that's good for the industry's collective understanding of systems is a fair debate. For actually shipping products, it's transformative.
What I Actually Spend My Time On Now
Less time: writing CRUD, configuring build tools, debugging environment parity issues, reading documentation for the third time because I forgot the exact signature of some method.
More time: thinking about data models, arguing with myself about UX flows, reading user feedback, refactoring things that technically work but feel wrong, and — this is the one that surprised me — writing. Writing specs, writing architecture docs, writing the plain-English description of what a feature is supposed to do before I build it. That last step used to feel like overhead. Now it's load-bearing.
When your AI collaborator can go from description to implementation with high fidelity, the description becomes the most important artifact you produce. The quality of your thinking determines the quality of the output in a way that wasn't as directly exposed before. Sloppy thinking used to hide inside the friction of implementation. Now there's nowhere to hide.
The Part I'm Still Figuring Out
I don't fully know what junior developers are supposed to learn anymore. The traditional path — write a lot of code, make mistakes, absorb patterns, develop taste — still works, but the feedback loops have changed shape. You can ship something that works without understanding it, which was always true but is more true now and faster than ever.
The developers I've seen grow quickly in this environment are the ones who treat AI output as a starting point for understanding rather than an ending point for production. They ask why. They break things intentionally. They read the generated code as carefully as they would if they'd written it, because they're building the mental model that the tool can't build for them.
The developers I've seen struggle are the ones who learned to prompt before they learned to debug.
I don't have a clean answer to this. I'm watching it play out in real time, same as everyone else.
Anyway
It's a weird time to be a programmer. The tools are extraordinary. The fundamentals still matter, maybe more than ever. The skill ceiling has gotten higher while the floor has gotten lower, and that's both democratizing and occasionally terrifying.
I'm building things in 2026 that I wouldn't have had the time or resources to build in 2020. That feels unambiguously good. How we adapt the craft to this new context — what we choose to keep, what we let go — that's the interesting question. We're all working it out as we go.
Ship the thing. Read the generated code. Know why it works. Get some sleep.
That's where I've landed, for now.