Welcome to the deep dive. We take interesting sources, find the core insights, and well help you get up to speed fast Exactly. Today we're diving into something huge, something that's really changing the game for software development.
It really is. The whole landscape is shifting.
It's not just about writing code anymore, is it. It's about you know, working alongside AI, AI assisted coding. What that actually means for programmers?
Yeah, the role is definitely evolving. And for this deep dive, we're leaning heavily on Addie Asmani's book Vibe Coding The Future of Programming, specifically the chapters on the seventy percent problem and beyond the seventy percent really insightful stuff.
Okay, great, So our mission today, let's unpack the reality of AI and coding. We want you to understand where it's genuinely good, where it will falls down, and crucially, how you, as a human developer can use your skills to thrive with these tools.
Right, it's about finding that synergy maximizing your human contribution in this sort of new AI powered world.
So let's kick things off with what Osmani calls the seventy percent problem. Because these AI tools I mean they are astonishingly good at certain things.
Oh, absolutely, generating boilerplate stand up functions. Yeah, they can turn that stuff out incredibly fast.
Yeah, getting projects like roughly seventy percent of the way there. It feels almost like magic sometimes it does.
But you know, it's fascinating how you hit this this wall after that initial burst. Peter Yang tweeted about this perfectly.
Oh yeah, what did you say?
He said that first seventy percent is super fast, but that last thirty percent is frustrating, like one step forward and two steps backward, new bugs popping up constantly.
Hmm. That rings true. It brings up this core idea, doesn't it. This complexity divide. Fred Brooks talked about this.
Ages ago, right, accidental complexity versus essential complexity.
Exactly an AI. It crushes the accidental stuff, the repetitive, mechanical, oftent tedious work.
Yeah, eats that for breakfast.
But the essential complexity, you're truly understanding the core problem managing its inherent difficulty. That's still firmly on us, on the human developers.
Absolutely, and that leads straight into what Osmoni calls the last mile gap.
The last mile explain that well.
The AI gives you a first draft basically a plausible solution, but that final thirty percent covering edge cases, refining the architecture so it actually scales, making sure it's maintainable long term. That needs a human, that needs serious human expertise. And AI might spit out a function that works fine for the main scenario, you know, but it won't automatically think about weird inputs or race conditions, performance issues, or what the system might.
Need next year unless you explicitly tell it to or like guide it really carefully with your prompt precisely.
You have to teach it in a way.
And this is where it gets well, maybe big concerning the AI's confidence often doesn't match its actual reliability.
Oh definitely. Stevie Edge had this great analogy. He compared LMS to wildly productive junior developers, super fast, super eager potential, actually whacked out on mind altering drugs, prone to coming up with crazy or unworkable approaches.
Huh Okay. That paints a picture. So what's the real danger there for a developer?
The danger is the AI doesn't really get the problem. It's just matching patterns from its training data. It's stitching things together. Right, Only a human, someone who deeply understands the domain the system, can spot if a solution that looks okay on the surface is actually hiding like long term land mines.
Land mines, I like that. AI doesn't invent new abstractions, does it.
It doesn't take responsibility, Nope, it remixes what it seems. So if it confidently gives you bad code and you don't catch it, while, that could be disastrous.
So okay, big picture, then what's the takeaway for US developers? AI is clearly a force multiplier, a turbo.
Boost definitely handles that maybe seventy percent of the grantwork, but.
It's absolutely not a silver bullet. It's not replacing human judgment, not at all.
That remaining harder thirty percent that still needs trained, thoughtful humans. That's where the real value add is now.
Okay, good, So moving on. Asani points out, these two distinct ways teams are actually using AI right now, the bootstrappers and the iterators.
Yeah, the bootstrappers, they're all about getting a new project off the ground zero to MVP right.
Using tools like bolt or V zero or those screenshot to code.
Things exactly imagine like a solo dev taking a Figma design and turning it into a working web app really really fast, in next to no time, as oz money puts it. That's bootstrapping with AI.
Wow, that's powerful for just getting ideas.
Out there quickly, totally great for validation. Then you have the iterators. These are the folks weaving AI into their daily.
Coding, like using Copilot or cursor, kline, windsurf. Yeah, those kinds of tools exactly.
They're using AI for com completion, refactoring, generating tests, writing docs, almost like a pair programmer.
Okay, so two different modes. Yeah, but there's always a button there. They're hidden costs here, failure patterns pop it out.
Yeah, definitely. One big one is this House of Cards code.
Puss of Cards sounds fragile, it is.
This happens when say, junior engineers just accept the AI's output too easily because it looks right. The code might seem complete, maybe even past basic tests, but under real world stress, it just collapses. It lacks that deeper architectural thought. They're robust error handling. A senior dev would build in HI. We stop that vigilance, good mentorship, because otherwise you fall into that two steps back anti pattern, Right, the one.
Yang mentioned fix one bug, the AI suggest to fix, and bam, that breaks two other things.
Exactly. It's this frustrating loop of diminishing returns, and this points to what Osmani calls a knowledge paradox.
Knowledge paradox.
Yeah, seniors use AI to go faster on things they already understand how to do, But juniors they sometimes try to use AI to figure out what to do in the first place.
Ah, so are they actually hindering their own learning? Is AI creating a skill gap?
That's a serious question and a real concern. It potentially could if not managed well.
And it gets even wilder with agentic AI.
Oh yeah, the autonomous agents like Devin AI clawd code.
These things don't just suggest code, They plan and execute whole tasks.
Pretty much minimal human input sometimes, which sounds amazing. But the risks they get amplified, like.
What just relying on it too much?
That plus not being able to step in easily if it goes off the rails, imagine cascading errors if you haven't audited its process properly.
How do you even audit something like that? Effectively?
It means you can't just check the final code. You need to understand its reasoning, trace its steps. Your own foundational knowledge becomes even more critical to spot the flaws it might introduce.
It really hammers home the need.
For fundamentals absolutely.
And then there's the demo quality trap. Ah.
Yes, AI builds a slick demo happy path works perfectly. Oh wow's everyone.
Looks great on Twitter exactly?
Yeah, but then real users touch it and all the missing polush shows up, weird error messages, crashes on edge cases, accessibility fails, performance nightmares.
Stuff AI didn't think about because it wasn't explicitly told to right.
Building truly self serve robust software that still takes human empathy, real world experience, and that deep sense of craftsmanship. AI isn't there yet.
Not even close. It sounds like no.
Okay, So given all this complexity, these traps, how do we actually use AI well day to day? Osmani says, Vibe coding isn't some weird separate thing, right, It can fit into agile DevOps totally.
It's about integration. One key pattern is AI as the first drafter.
So the AI writes the initial version.
Yeah, AI generates the code. Then the humans step in, refine it, refactor it, test it rigorously.
Makes sense. What are the key practices there?
Well, team coordination is huge, like talk and stand ups. Hey, I'm gonna use AI for this part. Agree on coding standards. Maybe even feed those standards to the AI.
Oh interesting, Give it context exactly.
And share good prompts. A well crafted prompt can save someone else a ton of time and version control. GET must be vital, more vital than ever. Commit often try to isolate the AI generated changes. Some teams tag commits like AI.
Not for blame, but for awareness.
Precisely so reviewers know, okay, give this bit an extra look for hidden assumptions or edge cases. It's like a little flag saying scrutinize me.
Got it? What's another pattern AI as a pair programmer. This is more of a hybrid.
Approach, blending human and machine.
Yeah, human intuition, machine speed. AI does the boilerplate, generate some tests, maybe the human does the critical review, ensures the quality.
Ask the right questions, so like I might ask the AI to draft code for integrating a new library.
Right, and then you take that draft and carefully check it against the official docs. You don't just trust it blindly.
How's that different from pairing with another human?
It's a different vibe. Human AI is great for rapid generation, getting scaffolding up fast. Human pairing still king for really deep problem solving, architectural debates, and just learning from each other.
Okay, best practices for this AI pairing keep AI sessions focused on distinct tasks so the context doesn't get muddy.
Write clear, focused prompts, review the output constantly, commit frequently, keep that feedback loop tight. Iterating with the.
AI makes sense.
And the last pattern, AI is a validator, using tools like deep code or snick for bugs and security issues, or things like test GTT or Quoto to help generate test cases.
So AI does the first pass.
Analysis, Yeah, spots the obvious stuff. Then human review focuses on the tricky bits, the complex logic, the user experience, any ethical concerns.
It's a collaboration, like a tireless intern, finding common mistakes, freeing you up for harder problems.
Exactly that.
Okay, This leads nicely into what osminding calls the golden rules of vibe coding. With all these possibilities and pitfalls, what are the absolute must dos? The core philosophy.
Rule one basically, be specific, clear prompts, Tell the AI exactly what you want, like giving instructions to that brilliant but very literal intern right. And then always always validate the output. Check it against your intent. Don't just assume it's right because it looks convincing.
Treat AI like a junior dev. Need supervision, constant supervision, and.
Use it to expand what you can do, not to switch off your brain. Don't let it replace your critical thinking. That's absolutely key.
Coordinate with your team before you start generating swaths of code with AI.
Yes, talk about it. Make AI use normal, transparent, not some hidden secret.
Isolate AI changes and get separate commits.
Makes life easier definitely, and ensure all code gets reviewed. Human written AI written doesn't matter. Code review is non negotiable.
And the big one. Don't merge code you don't understand, period, no matter how cool the AI made it look.
Couldn't agree more. And finally, prioritize documentation comments ADRs, especially for complex AI generated bits. Share good prompts, reflect on what's working what's not. Iterate.
These aren't just about getting code out faster, are they? They're about keeping quality, clarity, and control.
Exactly, maintaining sanity in this rapidly changing field.
Okay, so that brings us to beyond the seventy percent, that crucial thirty percent where human skills are just irreplaceable. This is where you really add value or future proof of your career.
Absolutely, this is the zone of maximum human contribution.
So for senior engineers, what does this look like?
You become the architect, the editor in chief. Let the AI be the fast typer generating the first draft, but you are the brain. You define the architecture. You've vet every line, you maintain the high standards.
You push back if people are just throwing raw AI code over the wall.
Exactly. You also use AI as that force multiplier for bigger, more ambitious projects. Steve yeggs these chat oriented programming or chop idea fits here.
Chop iterative prompting, Yeah, refining prompts.
Collaborating with the AI. It lowers the barrier to entry for those wouldn't be nice if projects that maybe seem too.
Big before and mentoring becomes even more critical for seniors.
Hugely coaching less experienced folks on how to use AI effectively, how to self review how to test properly, championing diligence and critical thinking about the AI's.
Output, Cultivating domain mastery using your history and business knowledge.
Right, that's how you catch the AI's subtle mistakes. Trust your gut. When code looks off, your experience often spots things the pattern matter misses.
And with AI handling some routine coding, seniors need to double down on soft skills leadership.
Totally communicating with stakeholders, leading design discussions, making those tough judgment calls. AI can't being the indispensable technical guide for the team.
Okay, what about mid level engineers. They might feel squeezed. Maybe tasks automating.
It's definitely a shift, but it's an elevation, not elimination. The key is adapt and specialize. How so deepen those CS fundamentals, data structures, algorithms, distributed systems, databases, networking. This stuff helps you manage the tricky integrations, the boundaries between systems, the edge cases AI flubs.
Become the integration expert.
Yeah, and build deep domain expertise. Finance, healthcare, and real time systems, places where nuanced human understanding is vital. Bridge that gap between code and real world impact.
Master performance and DevOps too.
Oh yeah, As generating code gets easier, making it perform well and deploy reliably becomes super valuable. Understand the whole stack, monitoring security costs.
And focus hard on code, reviewing QA relentlessly.
AI often gives you functional but horribly optimized code. As Osmani says, you need to be the quality gatekeeper. Develop a strong testing mindset, diagnose the complex bugs.
Learn systems big picture crucial.
AI doesn't currently get the user needs or business goals unless you tell it very specifically. You need to hold that context, see how all the pieces fit.
Together, and just keep learning right, be adapt.
On, stop, learn the fundamentals deeply, stay curious about AI tools, maybe even do those AI detox days to keep your own coding muscles strong, smart idea.
Communication skills too. Translating business needs.
More important than ever, and prompting AI well is actually a form of precise communication itself. Asking good questions both of humans and machines.
Learn system design and architecture.
Yes, designing robust, scalable, secure systems that needs an experienced human hand on the wheel. AI offers limited help there right now.
But still use the AI right, don't avoid.
It absolutely, use it daily, scaffolding prototypes, pair programming, repetitive stuff. Let it handle that while you focus higher.
Up and maybe venture into UIUX thinking.
Yeah, develop better product sends, Collaborate better with designers. Understand the user because coding itself might not be the bottleneck anymore. Understanding what to build and why that's key.
Okay. Finally, junior developers lots of anxiety. Maybe headlines about the death.
Of the junior death understandable anxiety, but the role is evolving, not vanishing. The bar might be rising. You need stronger fundamentals, faster perhaps, but you're needed to effectively use and validate these tools.
So number one piece of advice.
For juniors, learn the fundamentals, don't skip the y. Use AI like a tutor, ask it to explain things, but build your own mental model of data, structures, algorithms, memory. You need that to know when the AI is wrong.
Practice problem solving without the AI.
Sometimes yes, do those AI free days. Debug AI code yourself first before asking the AI to fix it. That builds real confidence and understanding. Don't outsource all the learning.
Focus on testing and verification. Challenge the AI's output exactly.
Write tests, for its code. Prof it works. Catching an AI bug that's pure human value right there.
Build an eye for maintainability. Go beyond just making it work.
Yeah, look at code structure style, refactor messy AI code. Internalize good design principle.
Develop prompt skills but wisely it's useful.
Sure, but good prompting often just reflects good understanding of the problem itself. Use AI like a supercharged stack overflow, a powerful assistant, not an oracle.
Seek feedback, mentorship from humans absolutely critical.
Learn the nuances, the trade offs, the soft skills from your team. Be open to feedback on your AI assisted code.
And remember communication and collaboration software as a team sport.
Always has been, always will be. Humans clarify requirements, coordinate, Even prompting is communication. Shift your mindset. Don't just consume AI answers, Understand them, dissect them. Learn how you could have gotten there yourself. That's how you level up.
So pulling it all together. The durable skills for the future in this AI world seem to be this in design systems thinking, critical thinking, domain expertise, quality is sharing and communication, adaptability, continuous learning.
That's the core list. These skills are durable because they don't become obsolete with the next AI model. If anything, AI makes them more important, right.
As Simon Wilson says, AI makes strong programming skills more valuable, not less.
Exactly, think of an experienced engineer like a seasoned pilot with a super advanced copilot. Faster journey, maybe farther, but the pilot still needs to navigate, make decisions, land the plane safely.
Software engineering was always about solving problems really, not just writing code lines Precisely.
AI doesn't change the fundamental goal. It just challenges us to solve problems at a higher level, maybe tackle things we thought were impossible before.
So the future involves less typing, maybe more directing and curating
Seems likely, but it will always always need human developers at the center, people with the wisdom, the judgment, the deep understanding to actually do it right.