Software Development and AI Videos

Lightly edited for clarity.

You hear a lot of predictions right now that AI will make programming obsolete, that developers will disappear, that college majors like computer science are already outdated.

They're not.

But the field is shifting. Not in what we learn, but in what that knowledge gets used for.

Computer science has always had two layers. One is technical: languages, frameworks, tools. And the other is structural: how humans coordinate to turn logic into value.

And the technical layer is changing fast. Every few months there's a new model, or a new API, or a new tool that reshapes what coding means.

In three years, students won't be writing as much raw code. They'll be describing behavior, verifying results, and orchestrating agents.

But the structural layer, how humans define problems, communicate intent, and decide what should be built, that part barely changes at all.

Teams still need people who can reason about systems, manage trade offs, and translate messy human goals into precise machine actions.

AI accelerates execution, but judgment, clarity, and deep thinking remain human.

So if you're studying computer science today, don't panic. But don’t stay static either.

Keep learning the fundamentals: logic, systems, data structures, architecture. And then also build the new muscle: prompt clarity, workflow design, AI integration.

The best developers in three years won't just know how to write code. They'll also know how to shape systems, human and machine, that produce better outcomes faster, with less friction.

AI is not the end of computer science. It's just the next layer of abstraction.

Learn to work with it, and you'll still be at the center of how technology gets built.

Lightly edited for clarity.

There's a quiet trend happening in tech right now of hiring fewer junior people.

Companies are looking at AI, seeing how much work it can automate, and deciding they can get by with a smaller, more senior team. And it does make financial sense on paper.

But strategically, it's a mistake.

Organizations don't just need output. They need fresh perspective. And when you stop bringing in new people, you stop bringing in new questions. You lose curiosity.

And curiosity is what keeps a company from quietly freezing in place.

Junior developers bring more than entry level skills. They bring unfiltered thinking. Why do we do it this way?

Those are questions that veterans stopped asking years ago.

They surface assumptions. They push at boundaries. And they see gaps that process heavy teams often overlook.

And yeah, AI can automate simple tasks that used to train juniors, but that just means the training has to evolve.

Instead of teaching syntax and setup, teach reasoning, debugging, and architecture.

Those are the skills that make AI an amplifier, not a crutch.

And forward thinking teams are already doing this, pairing early career engineers with AI to explore, test, and build systems end to end.

It's faster learning, and it injects new energy into the organization.

And without that, senior teams become echo chambers, technically excellent, but strategically stale.

AI doesn't make junior developers obsolete.

It makes their contribution, curiosity, adaptability, fresh eyes, even more essential.

If you want your company to keep evolving, keep hiring people who still ask why.

Lightly edited for clarity.

AI is changing how code gets written

But the bigger shift is how people learn.

Junior developers can now produce functional code in minutes, which sounds great until you realize they might not understand what they built.

Traditional mentorship models do not work at machine speed.

Historically, mentoring meant pairing, code reviews, and long apprenticeships through repetition. AI collapses that loop.

Developers get instant answers, sometimes correct and sometimes dangerous, and they move on before context catches up.

If mentorship still relies on “watch me do it” or “read the diff,” it misses the real failure points: reasoning, structure, and judgment.

The new role of a development manager is to teach context engineering.

Not just what a function does, but why it exists, where it fits, and how it interacts with the system.

AI can generate patterns. Humans must define boundaries.

Mentorship shifts from syntax correction to constraint definition.

What are we optimizing for? What is safe to delegate? What requires human review?

Replace tutorials with reasoning walkthroughs.

Pair programming becomes pair prompting.

Code review expands into process review.

Documentation becomes mentorship at scale.

Every test and comment teaches the next developer or model what good looks like.

The teams that adapt fastest are led by people who mentor through structure, not status.

They build shared mental models and cultures where AI is a partner, not a shortcut.

In an AI accelerated field, mentorship is not about passing down answers. It is about teaching how to ask better questions.

Lightly edited for clarity.

If you’re a student right now or you’re early in your career you’ve definitely noticed that things feel tighter. There’s fewer openings there’s higher expectations. Job descriptions ask for experience that you don’t have and AI seems to be moving faster than the traditional career ladder.

You’re not wrong. Entry level hiring has tightened across many industries and there’s lots of reasons for that. Part of that’s the economy. Companies are hiring more cautiously and running leaner.

Part of it is structural automation. AI are absorbing the mechanical repeatable tasks that used to serve as training grounds. That combination makes early roles harder to find not because the work is gone but because of being distributed differently.

The good news is that capability still compounds. The people who move ahead learn two things quickly how to use AI as an execution partner and how to think clearly about what they’re trying to accomplish.

You don’t need every framework or every tool. You need to know how to define a problem structure your approach and use AI to move faster through the learning loop from idea to test to feedback to refinement.

Those habits stand out. They signal that you can adapt reason and deliver. And that’s what hiring managers actually notice.

So if you’re still in school or you’re just getting started start building capability now. Use AI for research planning debugging writing anything that expands your ability to think and produce at a higher level. You’re not just doing tasks anymore. You’re learning how to design better ways of doing them. The path into the market is narrower but it is faster once you’re on it. So build these habits now so you can grow into the next layer of work not wait for it to come back.

Lightly edited for clarity.

A lot of developers still think of AI as autocomplete and it’s not. AI isn’t just speeding up code writing it’s reshaping how the entire workflow of software development fits together. If you understand that structure where human judgment lives and where machine acceleration makes sense you can move dramatically faster without losing control of quality.

The classic process hasn’t really changed in decades. You get a feature request you read the requirements you think through architecture design and data models you build it you test it you refactor it you document it and you deploy it.

An AI doesn’t replace that loop. It compresses the time between steps. Instead of spending an hour tracing similar code paths you can ask is there already a controller that handles something similar to this. And you get the answer in seconds. You still own the reasoning you’re just outsourcing the lookup.

When you get a new task don’t start by writing code. Start by asking AI to help you plan the build file structure end points data model UI updates. And the first plan won’t be perfect. You should assume it’s not. Your job is to iterate tighten the logic fix the naming and check the constraints. And once the plan matches your mental model that’s when you start building.

You turn prompting into an architectural conversation and AI shines in the middle of this loop which is debugging and clean up. You can ask why is this variable returning undefined. And have it trace the data path from the UI back to the API or back to the database in seconds.

And once you have the feature working have AI refactor the code. It is brutally efficient at pattern recognition consolidating logic normalizing naming spotting duplicate flows. Context matters. Give it the whole file or the module not just a fragment.

And most developers traditionally have skipped tests because they’re tedious and AI removes that excuse. You can ask it to generate unit tests covering positive and negative test cases and it gets most of the way there on the first pass. And the same goes for documentation summarizing classes and methods for internal docs.

These steps are no longer optional. They’re the guard rails that make hybrid development safe and code bases understandable for the next person or the next model. Think of AI first coding as collaborative engineering not automation. You’re still responsible for system design architectural integrity and judgment calls. AI clears friction so you can spend more time on structure and quality and reasoning. And those are the parts that define great software. AI doesn’t replace developers. It replaces friction.

Lightly edited for clarity.

AI can write code but accountability hasn’t moved. When you check code in you’re still signing your name to it whether you typed every line or orchestrated an agent that did. Ownership doesn’t disappear just because execution got faster.

AI can generate functions suggest refactors and scaffolded whole systems. That’s delegation. And delegation only works if judgment stays in the loop. You’re responsible for deciding what to hand off reviewing logic validating edge cases and making sure output aligns with real requirements.

The job is not changing from coder to prompt engineer it’s shifting from implementer to orchestrator. You define intent scope and constraints then guide AI through execution. Without clarity speed becomes confusion.

In production work AI does not free you from discipline it demands more of it. Testing documentation version control and code review aren’t overhead or optional. They’re safeguards.

If something fails in production it is not AI’s bug. It is your process that allowed it through. Learning to scale precision not just speed is the real professional shift.

Let AI draft debug and refactor but never let it decide what good means. Judgment still belongs to you.

Lightly edited for clarity.

AI’s made software faster to write but not safer to ship. Teams are finding out the hard way that acceleration without structure just multiplies entropy.

The two things that separate velocity from chaos are the same ones many teams used to skip testing and documentation. AI can produce clean working code in seconds but it can’t hold the system in its head. It doesn’t remember the trade off she made last quarter or the design decisions buried in a team’s thread.

Without documentation every developer human or AI walks into the project blind. Without tests there’s no ground truth. You don’t even necessarily know what correct means.

When AI enters that mix technical debt becomes amplified debt. Every gap in structure gets replicated at machine speed.

And for engineering leaders this isn’t a compliance problem. It is a leverage problem. A well tested well documented code base becomes training data for both people and models. Tests form feedback loops documentation becomes onboarding.

And leadership is not about enforcing this process for its own sake. It’s about scaling clarity as fast as you scale code. Treat tests as specifications not chores. Document intent not just implementation. Pair AI assisted commits with verification automated tests and human review.

This doesn’t slow teams down. It stabilizes acceleration. When teams get this right software quality improves as both teams and models evolve. AI is changing quality but not who owns it we still do.

Lightly edited for clarity.

Automation does something sneaky. It takes away the practice. When the system can automate drafts, code, research plans, people stop doing it normally and then become supervisors, which sounds like promotion or nightmare, depending on what you like about your job.

But here’s the thing. The system runs fine most of the time. And because it runs fine most of the time, you’re least prepared for when it doesn’t. And that’s not an AI problem, or even an automation problem really.

Your teams using AI to crank out client recommendations, right, week after week, you get polished decks. They’re clean, you can turn them out quickly. But one day the model misses something, security compliance, actual business reality, and now you have to catch it. But you haven’t been building that muscle because the system made it feel unnecessary.

Are you gonna catch it or is your process gonna let it through? Again, the differentiator isn’t just who can generate, everyone can generate. It’s who keeps judgment sharp, verification habits, escalation paths, decision logs, and failure drills for the weird cases.

Lightly edited for clarity.

I was talking to my brother the other day about how he uses AI, and one of the things that he does is ask it to build the fastest, most efficient plan possible, for whatever task he’s trying to accomplish, reduce the manual steps, cut the friction, get to the result quicker, which is really smart and makes perfect sense.

But as a counterpoint, AI is already making the work faster, 10faster50faster, sometimes10times faster. And so before you go looking for even more speed, maybe slow down for a second, and make sure you actually understand the problem. Look at your options. Build a mental model, train your judgment. See if there are different ways to approach this problem. Make sure you’ve got your car pointed in the right direction, before you hit the nitrous. Cause once AI’s in the loop, speed amplifies everything. If you’re headed the right way, that’s amazing. But if you’re headed the wrong way, and regardless, you still need structure and auditing and feedback loops, a way to catch mistakes as early as possible. Because speed doesn’t just amplify progress. It amplifies errors too.

Lightly edited for clarity.

This weekend I was working on some stuff, and I exceeded my GitHub Copilot token limit.

I was mostly finished, you know, the old way, before AI. And I haven’t forgotten how to code. I haven’t forgotten how to write software. But after spending the last couple of years mostly working with AI every day, it felt really slow.

And it reminded me of something. Writing code is not really the most difficult part of software development, but it traditionally has been the most time-consuming. The hard part’s always been figuring out what to build and exactly how to build it. Understanding the requirements, finding the edge cases, realizing business rules contradict each other, or figuring out that one small change here breaks things elsewhere. And that’s where experienced engineers spend most of their time.

AI has fundamentally changed the economics of software development. Writing code is dramatically faster than it used to be, but it doesn’t eliminate the need for good decisions. And in fact, it does the opposite. The easier it becomes to build something, the more important it becomes to know exactly what should be built.

You can’t hand AI a prompt that says, “Build me a website. It should be cool.” You have to tell it exactly what success looks like.

Lightly edited for clarity.

One of the weird things I’ve noticed about AI is that it sometimes creates work faster than it automates it, and I’ve run into this three times recently.

The first was a website performance project. We wanted to reduce cumulative layout shift, which is when you load a web page, the pieces and images move around. That’s called layout shift. So the way to fix that in a CMS-driven website is to specify the correct dimensions for the images. And a few years ago, that would have meant a lot of manual testing and manual review. Instead, I generated the code changes with AI. I built a crawler with AI, I generated screenshots of the entire site, and then I compared the before and after results with AI, and then fixed the outliers, again with AI.

The second was an SEO project. We wanted every URL on the site to use the correct canonical format, and it required updates to both code and content. So again, instead of reviewing pages manually, we crawled the entire site, generated a report of every issue, fed that report back into AI, found every place URLs were rendered, and then fixed them systematically.

And I see the same thing happening in marketing. What used to be one campaign is now becoming several: checking accounts for young adults and retirees and small businesses, and for different geographies.

I realized these are all the same story. AI makes generation really cheap, and when generation becomes cheap, you do more of it. And that creates more code to test, more content to review, more campaigns to validate, more experiments to measure.

AI is automating a lot of tasks in jobs right now, but it is also creating more work to do.

Lightly edited for clarity.

I met something like 50 new people in the last few weeks. It’s been really amazing. Last week I went to a meetup, and I met a bunch of solo founders, people that are building small businesses.

And it’s interesting how many of them start with domain expertise, not really technical know-how. They understand a specific industry, and they’ve worked inside a particular process. They’ve experienced a problem enough times, know exactly what was broken and what a useful solution would be.

And even a year ago, turning an idea like that into a software business might have involved raising money, finding a technical co-founder, or hiring a development team before you can really even find out whether or not that idea worked.

And AI’s lowered the barrier dramatically. People who understand the problem can now build a product, and test it with real users, and start a business in way less time and with way less money than was practical even a year ago.

And we’re gonna see a lot more businesses created this way. The person who deeply understands the problem can increasingly become the person who builds a solution.