AI is changing how software is built. What used to take days can now take hours. Teams can deliver faster than ever, but speed also introduces a new set of challenges. 

At CAPE Digital Solutions, we sit right at the intersection of AI, custom software, and low-code platforms such as Mendix. The productivity gains are absolutely real. But whether AI helps or hurts, depends on how teams manage quality, governance, and learning. 

Here are five practical learnings from building software with AI in real delivery environments over the last year: 

1. Junior developers deliver faster, but not deeper 
2. Faster development does not mean better outcomes 
3. Senior developers become more important 
4. Quality must scale with speed 
5. AI can slow down skill development 

One thing we’ve clearly noticed: recent hires are able to develop much quicker than when many of us started 5–10 years ago. 

With AI, they can find answers instantly. Instead of waiting for an expert to respond to a question, they can ask an AI assistant, get an explanation, generate an example, and keep moving. 

This means junior developers can contribute earlier. They can: 

• build interfaces faster 
• automate workflows quicker 
• implement common integrations with less friction 

But there’s also a trade-off.  Faster output doesn’t automatically mean stronger understanding. AI helps with execution, but it doesn’t replace experience or judgment. And this links directly to learnings #3 and #4: if output grows faster than understanding, the system needs more oversight and stronger quality controls. 

Takeaway: AI accelerates delivery speed, not expertise. 

2.  Faster Development Doesn’t Mean Better Outcomes (Technical and Business)

AI makes it easier to build quickly but it doesn’t guarantee you’re building the right thing. 

Technically 
AI can fill knowledge gaps that used to take years to build. Juniors can now produce outcomes that look “mid-level” or even “senior” at first glance. 

But often they can’t oversee the impact. AI guides them to an answer, but it doesn’t: 

• understand your full context 
• highlight every consequence 
• teach the fundamentals along the way 

So you can end up with something that works today, but creates issues later like performance, security, maintainability, or architectural consistency. 

From a business outcome perspective 
This is the part I keep coming back to: building custom software is not primarily a coding challenge. The hard part is understanding what the business truly wants, and often the business doesn’t fully know either.  
A classic example we still see all the time: 

“We’ve been using this paper form for years — can you put it on a tablet?” 

Sure. AI makes digitising a form very easy. But the better question is: 

“Is the form the problem — or is it a symptom?” 

Maybe the root cause is the process behind it. Maybe the information already exists somewhere else. Maybe the form is compensating for a broken upstream step. If you don’t ask the “why” questions (sometimes literally the 5 Whys), you can build a beautiful digital version of the wrong solution, faster than ever. 

Most delivery challenges are still driven by: 

• unclear requirements 
• misaligned stakeholders 
• inefficient processes 

AI accelerates the output. But you still need to validate the outcome. 

Takeaway: Strong product thinking remains essential. 

3. Senior Developers Become More Important 

As teams produce more output, the need for oversight increases. 
Previously, juniors needed time to build capability. They had to learn fundamentals, make mistakes, and gradually develop judgment. Now they can create complex output in seconds — often without understanding the technical consequences, and sometimes without being able to judge whether it’s the right solution for the business. 

There’s a reality here that I don’t think we can avoid: 

AI increases delivery speed, but it can also skip the fundamentals.
And without fundamentals, you won’t understand the consequences of your decisions. 

This creates pressure on senior engineers. They increasingly need to: 

• validate architectural decisions 
• review for security and compliance 
• protect long-term maintainability 
• align changes across the wider system 

The risk is that seniors become “fixers” — constantly cleaning up and validating — instead of doing the work they should be doing: designing, guiding, and uplifting the team. 

In my view, the best answer isn’t just “review more.” It’s also: teach more deliberately, because the old learning path (repetition → mistakes → mastery) is being disrupted. 

Takeaway: AI increases delivery speed, but it also increases the need for strong senior leadership. 

4. Quality Must Scale with Speed 

Manual quality control can’t keep up with AI-driven output. This connects directly to the point above: seniors simply cannot review everything deeply when volume increases and complexity increases at the same time. 

A dynamic we’re seeing more often: 

• Teams produce more code faster 
• Changes become larger and more frequent 
• Review load grows 
• Quality becomes inconsistent 

To maintain reliability, teams need stronger foundations: 

• automated testing 
• CI/CD pipelines 
• security checks (SAST/DAST, dependency scanning, etc.) 
• monitoring and observability 

Without these, faster development just pushes risk into production — faster. 

And yes, we often hear: 

“We’re not ready to invest in that yet — it’s expensive.” 

But with increased speed, quality investment becomes less optional. I sometimes describe it as “insurance”: the faster you move, the more you need safeguards. 

Takeaway: If delivery accelerates, your quality controls must scale accordingly. 

 5. AI Can Slow Down Skill Development

This one is easy to miss at first.  AI reduces the need for repetition — and repetition is how many developers traditionally learn. You usually build fundamentals step by step before moving to the next level.  Now, people can jump straight to “level 10” output. But skill still takes time — not time writing code, but time developing understanding. 

This can create a gap where developers produce results without fully understanding them. Over time, that affects: 

• system design thinking 
• problem-solving ability 
• the maintainability of solutions 

In a way, this reminds me of what happened decades ago when we moved from machine code to higher-level languages. It sped everything up — and that was great. But even then: 

• the best engineers still understood what was happening underneath 
• the rest created problems that only showed up later 

AI is amplifying that effect. It enables people (including developers) to create things they don’t fully understand. 

Takeaway: Learning must be deliberate in AI-driven teams.