How AI is going to change software development

by Eric Picard

As someone who’s spent decades watching technology waves crash over the software industry, I find myself constantly recalibrating my predictions about AI’s impact on how we build software. Two years ago, I wrote about the potential for AI to create massive productivity gains and fundamentally alter development practices. Now, with some genuinely surprising developments happening right under our noses, I can see we’re heading somewhere much more interesting than I initially thought.

The productivity gains from AI tools like GitHub Copilot, ChatGPT, Cursor, and Replit are real, but what’s caught my attention is how we’re seeing two distinct paths emerge. Professional developers are using AI as incredibly powerful assistants, while non-developers are essentially managing teams of AI-powered junior developers through conversational interfaces. Both approaches are working, just for different types of projects and different scales of ambition.

Two Worlds of AI-Powered Development

Professional developers have largely embraced AI as sophisticated tooling that makes them dramatically more effective. They’re using AI for code generation, debugging assistance, refactoring, and rapid prototyping, but they’re doing it within established architectural patterns and development methodologies. The productivity gains are genuine – I’m consistently hearing reports of 30-50% improvements in specific tasks – but these developers maintain architectural oversight and code comprehension. I’ve talked to several developers who are often referred to as “10x” developers, meaning they’re ten times more effective than others on their teams. These particular developers were 10x devs at big tech companies, so certainly more than 10 times most developers. Each of them has told me that they are 100X-ing themselves using AI. So this is not a small change.

Then there’s what Andrej Karpathy coined “vibe coding” – developers describing what they want in plain English and accepting AI-generated code without necessarily understanding every line. This “fully giving into the vibes” approach emphasizes rapid experimentation over careful architectural planning. Y Combinator reported that 25% of their Winter 2025 batch had codebases that were 95% AI-generated, which represents a fundamentally different relationship with code creation.

The key insight is that these aren’t competing approaches – they’re serving different needs. Professional development teams use AI to accelerate work within proven frameworks, while vibe coding enables non-developers or small teams to build functional applications that would have been impossible for them to create just a few years ago.

Replit: DevOps Intelligence for the AI Era

Replit’s explosive growth – from $10M to $100M ARR in less than six months – illustrates something important about where this is heading. Replit is actually the intelligent evolution of DevOps principles, bringing continuous integration, automated testing, and deployment automation to AI-driven development.

Traditional DevOps emerged because managing infrastructure, deployment pipelines, and scaling manually was becoming impossible at scale. Smart development teams adopted CI/CD, automated testing, infrastructure as code, and monitoring because these practices made complex systems manageable and reliable.

Replit takes these same principles and makes them accessible through conversational interfaces. When their AI Agent selects a tech stack, generates code, sets up databases, and handles deployment, it’s not eliminating DevOps – it’s automating DevOps intelligence so that non-developers can benefit from these practices without needing to understand them deeply.

This matters because it’s expanding who can build functional software. You don’t need to understand Kubernetes, Docker, CI/CD pipelines, or infrastructure configuration to get the benefits of modern deployment practices. The AI handles the complexity while applying proven DevOps principles under the hood.

The Custom Application Renaissance

What excites me most about this trend is that we’re finally approaching the custom application future that the internet promised but never quite delivered. For twenty years, we’ve talked about having rich, customized web applications for internal business processes, but the development overhead made it impractical for most organizations.

Now we’re entering an era where custom web applications for fairly complex business tasks can be built quickly and cost-effectively. The “intranet” that organizations have wished for – dynamic, task-specific applications that actually solve their particular workflow problems – is becoming achievable. Just this week I built two very powerful internal apps for one of my clients inside of CharmIQ. These apps automate extremely intensive processes that were bottlenecks for my client. And three weeks ago, I had no idea how to do this. I’d have hired someone to build them.

I’m hearing about custom applications for everything from inventory management to customer onboarding to internal reporting, applications that would have required months of development and significant ongoing maintenance. These aren’t replacing enterprise software entirely, but they’re filling the gaps where off-the-shelf solutions don’t quite fit.

The Architecture Challenge Ahead

As these AI-powered development approaches mature, we’re approaching a fundamental architectural question. Current approaches work well for their respective use cases, but we need architectural patterns optimized for AI collaboration rather than just AI assistance. Right now AI developers are about as talented as junior developers – with maybe 2-3 years of experience. They break things a lot, the code isn’t efficient, they’re not always architecting things properly. But that’s a short-term problem – we’re only a few years away from AI developing software as well as any human, or better. What happens then?

The traditional monolithic applications or coarse-grained microservices that work well for human development teams may not be optimal for AI-powered development environments. Some teams experiment with treating code as completely disposable, letting AI regenerate implementations for each iteration. This works for prototypes and simple applications, but it breaks down for complex systems where you lose accumulated knowledge and performance optimizations.

Components: The Architecture for AI Collaboration

I think the future lies in component-based architectures that provide the right granularity for AI systems to work effectively. This draws inspiration from earlier component models like Microsoft’s COM objects, adapted for modern cloud environments and AI capabilities.

Applications would be built from well-defined components with stable interfaces and clear functional boundaries. Each component handles specific capabilities – user authentication, payment processing, data transformation, content generation – with explicit contracts for inputs and outputs. The critical insight is that while these interfaces remain stable, AI systems can continuously optimize, refactor, or completely reimplement the internal logic of individual components.

This architecture offers several advantages for AI-powered development. Components provide bounded problem spaces where AI systems can operate effectively without breaking broader system functionality. The stable interfaces enable comprehensive testing and debugging, while internal flexibility allows for continuous optimization based on performance data and changing requirements.

What This Looks Like in Practice

Over the next five to ten years, I expect we’ll see component registries emerge that catalog available functionality with detailed specifications. AI systems will continuously monitor component performance and generate optimized versions for testing and gradual deployment.

Applications will become more dynamic, automatically reconfiguring by swapping component implementations based on load patterns, user behavior, or resource availability. Unlike current microservices managed by human teams, these components would be maintained by AI systems operating within architectural guidelines defined by human engineers. And eventually, we may even let the AI take that over too.

The development process shifts toward interface-first design, where human architects focus on defining component boundaries and interactions, while AI systems handle implementation details. This division of labor plays to respective strengths: humans excel at architectural thinking and business requirements, while AI systems optimize implementations and handle routine coding tasks. And as the AI gets better and better at architecture and business requirements development, we may see a whole new world emerge.

The Transition Path Forward

This transformation is happening gradually but accelerating quickly. Professional developers are becoming more effective through AI assistance while maintaining architectural oversight. Non-developers are building functional applications through conversational interfaces that would have been impossible for them to create previously.

Current service-oriented architectures provide a foundation that can evolve toward component models as AI capabilities mature. Organizations with good interface design practices, comprehensive testing strategies, and strong observability will be best positioned for this transition.

The engineers who thrive will be those who can think architecturally about system design while effectively directing AI systems. Product managers become even more critical because rapid prototyping capabilities make clear product vision, competitive intelligence, customer-centric approaches and market understanding the primary competitive differentiators.

The Strategic Reality

As we move toward this future, competition shifts in important ways. Technical barriers to building certain types of software continue falling, but success increasingly depends on architectural excellence and product strategy rather than implementation speed alone.

Organizations that can design effective component architectures and orchestrate AI development systems will gain significant advantages in both development velocity and system reliability. The ability to continuously optimize software systems without traditional refactoring risks could become a major competitive edge.

However, this also presents new challenges around managing dynamic system complexity, ensuring security across AI-generated code, and maintaining coherent user experiences across rapidly evolving implementations.

The transformation isn’t about replacing human engineers – it’s about creating new collaboration models between human architectural thinking and AI implementation capabilities. The future belongs to organizations that can effectively combine these strengths while maintaining clear product vision and strategic focus.

We’re witnessing a shift from static implementations toward dynamic, continuously optimizing systems. While full realization is still years away, the foundation is being built through current experiments with AI-assisted development, vibe coding platforms, and component-based architectures. Replit’s growth numbers suggest this isn’t theoretical anymore – it’s happening faster than most of us expected, and the organizations preparing now will be best positioned to capitalize on the opportunities it creates.