Over the past two months, I worked extensively with generative AI (Claude Code) to build a complex enterprise-grade system, from simple data retrieval and UI interactions to an integrated data mart and backend infrastructure. This was not a static or well-defined task. In fact, the project was intentionally designed to be Agile: the requirements changed rapidly, the priorities shifted frequently, and iterative feedback was an important part of the process. AI was embedded in the development workflow at every step — not just as a code generator, but as a partner.
This note isn’t a technical breakdown of what I built. Instead, it’s my perspective on the collaboration between a senior human software architect and a powerful AI code agent. I assess what worked and what didn’t. I share my take on embedding AI as collaborator in software development teams and incorporating these agents in companies’ technology strategy. Finally, I describe my perception of the impact of these AI code agents on the future of software development, particularly how I expect these agents to drive the evolution of the role of senior developers and architects in the age of AI.
Tools, Technology, and Working Context
The system I developed was built using .NET Aspire, .NET 8, MVC Framework, Entity Framework, SQL Server, and JavaScript (with extensive packages and integration like Prometheus and Jaeger), deployed in a typical enterprise stack. The process, however, was just as important as the technology. I worked in an Agile model, not because I had to, but because it created a realistic test case: Could AI support software development in a real-world environment where requirements are fluid and design decisions evolve?
Spoiler: It could... but not without significant human guidance.
Building With AI: Speed Meets Fragility
Working with AI felt like collaborating with a junior developer who could write fast, generate patterns on demand, and never get tired. Need five controller methods refactored? Done in seconds. Want a comparison of two architectural options? Generated instantly and with citations. The speed was remarkable.
Speed is useful, but it isn’t everything.
In a constantly shifting Agile environment, AI struggled to maintain state across iterations. A change in a model one day broke code that AI generated the day before. Assumptions baked into previous solutions didn’t always carry forward. I found that I needed to reexplain the context often. In short: AI could generate great code, but it lacked a robust understanding of the system’s evolving architecture.
Steering this process is where my role as a senior developer became irreplaceable. I had to continuously evaluate whether AI suggestions still fit the direction of the system. I had to revise architectural decisions, redesign parts of the flow, and rethink priorities based on business input that AI couldn’t possibly know.
What AI Does Well
Despite its limitations, let’s give AI credit where it’s due. AI tools like Claude are phenomenal at:
- Generating boilerplate and repetitive code
- Applying common architectural patterns (MVC, repository, DI, etc.)
- Refactoring code structures with consistency
- Producing documentation and explaining code logic - Adapting quickly to feedback (if the feedback is explicit and well scoped)
In a stable environment with clear instructions, this alone can dramatically increase developer productivity.
Where AI Falls Short—Especially in Agile Environments
When the ground keeps shifting, as it does in any Agile system with evolving requirements, AI’s limitations are quickly revealed:
- Overengineering simple problems
- Inability to handle business logic drift
- Debugging and runtime insight
- Lack of persistent context (despite being a memory-aware agent)
Regarding this last point, I understand that Claude Code is supposed to be a memory-aware agent, but in practice I found its memory to be inconsistent. It could remember things within a session, but didn’t retain architectural context or past decisions well over time. As I described earlier, I often had to re-explain problems, even ones we had already solved. This lack of persistent context is a major limitation for real-world development in Agile environments.
The Myth of “Juniors + AI = Seniors”
It’s tempting to ask: Can we replace expensive senior developers with less experienced staff armed with AI tools? My answer, based on my experience: not yet, and maybe never fully.
A junior developer plus AI can get further today than ever before. They can generate UI components, call stored procedures, scaffold database models, and integrate APIs. But without architectural vision, they’ll build something that works—until it doesn’t. And when it breaks, they may not know why.
AI still depends on human judgment. When should I refactor? When should I abstract? When should I reject AI’s suggestions entirely because they miss the point? These are senior calls.
In Agile environments, these decisions are even more critical. Every sprint may change assumptions. Every planning meeting may introduce new edge cases.
Are We at Peak AI?
That’s debatable. Current AI tools are extremely capable, but they’re trained on vast corpora that include their own outputs. We’re entering a period where AI-generated content is feeding future models. That introduces a feedback loop that could reduce quality, originality, or accuracy over time.
What’s more likely is a plateau. Not in the sense of raw intelligence, but in practical utility. The next breakthrough may not come from larger models, but from better human-AI collaboration interfaces, memory-aware agents, or systems integrated deeply with runtime environments.
Until then, AI’s best use is acceleration, not autonomy.
What This Means for the Senior Developer
If you're a senior developer, your role is evolving, but it’s not disappearing. You’re not just coding anymore. You’re steering. You’re curating. You’re translating changing requirements into architectural decisions. You’re mentoring the AI as much as you’re using it.
And perhaps most importantly, you're managing uncertainty. That’s where experience matters more than ever. You’ll work faster with AI.
You’ll offload more tedious tasks, but the judgment calls that shape the system will remain yours to make.
A Final Thought
After two months of building a complex application alongside AI, I’m convinced that we’re not heading toward a future where humans are replaced. We’re moving toward a hybrid model where those who know how to use AI thoughtfully will outpace those who don’t.
That use requires skill. It requires architecture thinking, communication clarity, and the ability to change direction when requirements shift, sometimes daily.
In Agile environments, where requirement changes aren’t bugs but features, AI can’t lead. It can only follow. And it needs someone capable to lead it well.
That’s where senior developers still matter.
