The Human Touch: Web development and AI

Everyone wants to talk about what AI changed. And yes — a lot changed. We can scaffold a full application in hours, generate component libraries on demand, and ship features that would have taken a sprint in an afternoon. We've felt that shift directly in how we build products like MyMoneyRight.ai. AI is a real force multiplier.

But there's a conversation we're not having enough, and it's the one that matters just as much: what didn't change. Because if you go into AI-assisted development thinking the hard parts went away, you're going to ship broken software faster than ever before. That's not progress. That's just expensive mistakes at higher velocity.

Here's what we've learned — and what every builder needs to understand before they hand too much over to the machine.

Requirements Gathering Still Requires Humans in a Room

AI can help you document requirements. It can help you organize them, spot gaps, and even generate user stories. What it cannot do is figure out what people actually need when they don't fully know themselves. That discovery process — the back-and-forth with stakeholders, the half-formed ideas that turn into core features, the moment someone says "well, what I really mean is..." — that's still entirely human work.

We've seen this play out on our own projects. You can prompt an AI with everything you think you know and get back a perfectly structured spec. But if your inputs were incomplete or slightly off-target, the AI will confidently build you the wrong thing. Garbage in, garbage out didn't stop being true just because the garbage now comes out faster and looks more polished.

Good requirements gathering is still about listening, probing, and validating assumptions with real users and real stakeholders. AI is a tool to help you capture and structure what you've already discovered. It's not a substitute for the discovery itself.

Testing Is More Important Than Ever, Not Less

This one is counterintuitive enough that it trips a lot of people up. AI can generate tests — unit tests, integration tests, even end-to-end test scaffolding. So you might think testing gets easier and therefore less important. The opposite is true.

When AI writes code, it writes code that looks correct. It compiles. It follows patterns. It is often logically coherent. And it can still be subtly, dangerously wrong in ways that only surface under specific conditions. AI-generated code inherits all the risks of code written by a developer who was smart but didn't fully understand the business context — because that's essentially what it is.

Your test suite is now the primary line of defense against confident-sounding code that does the wrong thing. If you're shipping AI-assisted features without rigorous testing, you're not developing faster — you're borrowing time from a future incident. The testing discipline hasn't relaxed. If anything, your test coverage needs to be sharper because you're producing more code, more quickly, with less line-by-line human scrutiny.

Change Management Is Still a People Problem

Software doesn't fail in production because the code was bad. It often fails because the people using it — or the teams supporting it — weren't ready for it. Change management is about managing human expectations, workflows, and resistance. AI has nothing useful to say about why your operations team is nervous about the new system, or why the end users keep reverting to the spreadsheet they've used for ten years.

If you're building internal tools, client-facing platforms, or anything that changes how an organization operates, the rollout strategy matters as much as the build. Stakeholder communication, training, phased deployments, feedback loops — these are human-to-human conversations. They always were. AI can help you write the training documentation, but it can't build the organizational trust that makes people actually use the new tool.

We've watched otherwise excellent software projects stumble at this stage. The code worked perfectly. The adoption didn't. No amount of AI capability addresses that gap.

Security Doesn't Get Smarter Just Because Your Stack Did

This is the one that keeps us up at night, honestly. AI-assisted development can introduce security vulnerabilities in ways that are particularly sneaky. The code looks clean. It follows conventions. It may even pass a basic code review. But AI models are trained on the entire internet — including all the bad patterns, the deprecated approaches, the half-fixed vulnerabilities that made it into public repositories.

Security management in web development still demands the same fundamentals: threat modeling, dependency auditing, penetration testing, access control reviews, and keeping up with CVEs. None of that changed. What changed is that you now need to add "review AI-generated code with a security lens" to your checklist, because the volume of code you're shipping went up while the per-line human review time went down.

For products like ours — where we handle personal financial data and have made a firm commitment not to sell or misuse user information — security isn't a feature. It's a foundation. AI tools help us build faster, but they don't audit our authentication flows or validate our data handling practices. We still do that the old-fashioned way: carefully, methodically, and with outside eyes when possible.

Monitoring Still Assumes Something Will Go Wrong

Production monitoring exists for one reason: because software breaks in ways you didn't predict. AI doesn't change that fundamental truth. In fact, because AI-assisted development can move quickly through edge cases without fully reasoning about failure modes, your observability layer is more critical than ever.

Logging, alerting, performance monitoring, error tracking, uptime checks — these aren't exciting. They're not the part of the project anyone wants to talk about at the demo. But they're what separates a professional software operation from a hobby project. When something breaks at 2am (and something always breaks at 2am), you need visibility into what happened and why. AI didn't build that visibility for you. You have to build it intentionally.

The goal of monitoring is to make the unknown, known — and to make the painful, recoverable. Neither of those goals changed with the arrival of AI. If anything, faster shipping cycles mean more frequent deployments, which means more opportunities for production surprises. Your monitoring needs to keep pace with your deployment frequency, not sit as an afterthought.

The Craft Didn't Go Anywhere

Here's the bigger point underneath all of this: AI accelerated the building, not the thinking. The judgment calls that make software good — understanding what users actually need, validating that the system behaves correctly, managing organizational change, protecting data, and knowing when something's wrong — those still require experienced, thoughtful people who care about what they're building.

We've been building web software since 2006. We watched the internet collapse distance. We're watching AI collapse expertise. But even when expertise gets cheaper and faster to access, wisdom about how to apply it correctly — that's still the job. That didn't change. That's not going to change.

The builders who understand this will use AI to do more of the right things, faster. The ones who don't will use AI to do the wrong things at scale. The difference isn't the tools. It never was.