Our Stance on AI and Agentic Coding

AI in the software development lifecycle

By Brava Software Solutions · Updated August 2026

Well, here we are in the midst of another technology revolution!

The addition of AI to the software development lifecycle has rapidly increased the speed at which software can be planned, prototyped and developed. At Brava, we’re excited by what this makes possible for our clients. However, faster development does not automatically mean better software. As with any tool, AI-assisted and agentic coding produces the best results when used with care, judgement and experience.

The trade-offs of agentic coding

If you’re not a software developer, it can be difficult to know exactly what an AI coding tool has produced. You may have something that appears to work, but that does not necessarily mean it is reliable, secure or ready to be used in a real business environment.

Some of the potential risks include:

• Not knowing how the software works: The code may achieve the desired result, but be difficult to understand, maintain or extend later.
• Security concerns: AI-generated code can contain vulnerabilities, unsafe assumptions or weaknesses in areas such as authentication, data handling and access control.
• Hidden technical debt: A quick prototype can accumulate shortcuts and unnecessary complexity, making future changes more expensive.
• Inconsistent quality: Generated code may vary in style and quality from one part of a project to another.
• Unnecessary complexity: AI tools can sometimes introduce elaborate solutions where a simpler approach would be more robust.
• Reliability problems: Software that works in a demonstration may still fail with unusual inputs, larger volumes of data or multiple users.
• Limited familiarity: If nobody involved understands the underlying code, fixing a problem when something goes wrong can be difficult and costly.
• Data and intellectual property concerns: Sensitive business information, customer data or proprietary ideas need to be handled carefully when using external AI services.
• Ongoing dependency: A project may become tied to a particular tool, model, framework or generated approach that is difficult to replace later.
• False confidence: Perhaps the biggest risk is believing that a working prototype is the same thing as production-ready software.

Of course this doesn’t mean that AI coding tools should be avoided. It means they should be used as part of a sensible development process, rather than treated as a replacement for one.

Three ways we can help

We’re a team of hands-on developers, and we love nothing more than solving difficult problems and taking pride in the software we create. We have been writing, reviewing and maintaining production software for over two decades, and we understand the value of careful design and attention to detail.

At the same time, we appreciate that not every project needs the same development approach. Some clients need the highest possible level of control and craftsmanship. Others need to move quickly, test an idea or make the most of a limited budget.

That is why we offer three complementary approaches. AI is simply another option for helping clients communicate their vision, explore an idea and reduce development time or cost where appropriate.

We can also mix and match these approaches throughout a project. For example, we might use AI to help explore an initial idea, build the core system using a supervised development process, and then hand-code particularly sensitive or performance-critical components.

1Hand-coded bespoke software

This is the approach we have traditionally offered, and it remains the right choice for projects that require the highest level of care, control and attention to detail.

Our developers design and write the software directly, making deliberate decisions about the architecture, user experience, data structures, integrations, security and long-term maintainability. Every part of the system can be carefully considered and refined to suit the specific needs of your business.

It is a little like commissioning a craftsman to create a bespoke piece of furniture. The budget may be higher and the work may take longer, but the result is designed specifically for you, built with care and made to last.

This approach can be particularly valuable when:

• The software is business-critical.
• Security or regulatory requirements are especially important.
• The system needs to integrate with complex existing infrastructure.
• Long-term maintainability is a priority.
• The project involves unusual technical or performance requirements.
• You want complete control over how the software is designed and built.

For these projects, traditional development provides a high level of transparency and confidence from the beginning.

2Augmented, agent-driven development

Our second option combines experienced human developers with modern AI coding tools.

In this approach, our developers remain firmly in the driving seat. We design the system, establish the architecture, make the important technical decisions and oversee the development process. AI agents can then help us move more quickly through tasks such as:

• Exploring possible technical approaches.
• Producing early prototypes.
• Investigating unfamiliar libraries or technologies.
• Creating initial implementations.
• Generating repetitive code.
• Producing test cases and documentation.
• Reviewing code for potential issues.
• Speeding up routine development work.

The main benefit of this approach is speed. Some projects need to reach their destination quickly. You may need to test an idea, replace an inefficient manual process or get a useful internal tool into people’s hands without investing in a fully polished bespoke system from day one.

However, there is a trade-off. Although the code is guided and reviewed by experienced developers, it is not necessarily as carefully crafted, consistent or familiar to us as code we have designed and written entirely by hand. We may understand what it does and how to maintain it, but the underlying implementation may contain more generated code, shortcuts or inconsistencies than we would normally choose for a fully bespoke build.

That can mean:

• The code may be less polished than a traditionally hand-coded system.
• Some areas may be more difficult to understand or extend later.
• The application may require additional refinement as it grows.
• The initial architecture may be more pragmatic than perfect.
• Future improvements may involve refactoring or replacing parts of the system.
• The software may be less suitable for particularly sensitive, complex or business-critical requirements.

This is not necessarily a problem. Not every project needs the same level of finish from the outset. Sometimes the most sensible decision is to get a useful solution working quickly, learn from how it is used and improve it over time.

We still apply our experience throughout the process. We establish sensible foundations, identify important risks, review the generated code and test the resulting software. We will also hand-code or rebuild areas where security, performance, reliability or long-term maintainability require a higher level of attention.

The result is a practical compromise: faster and more cost-effective than a fully hand-coded project, while still benefiting from experienced software developers who understand the decisions being made. It may not offer quite the same level of polish or familiarity as our first option, but for the right project, reaching a useful destination sooner can be more valuable than taking the longest possible route.

This approach can be particularly suitable when:

• You need to validate an idea quickly.
• The software is for internal use or a limited audience.
• You are replacing a manual process and want results sooner.
• You have a tight initial budget.
• You expect the requirements to develop as the software is used.
• You want to launch a first version before committing to a more comprehensive build.

As with all our approaches, we will be clear about the trade-offs and help you decide where speed, cost and finish should sit in relation to one another. We can also combine agent-driven development with hand-coded work, using the more traditional approach for the parts of your system where it matters most.

3Turning your AI-generated prototype into real software

AI coding tools have created an exciting new way for people to communicate their ideas.

You may already have used a tool such as Claude, ChatGPT or another AI development environment to create a prototype. Perhaps it does something remarkably close to what you imagined. Maybe you have even started using it internally.

But you may also be wondering:

• How does this code actually work?
• Is it secure?
• What happens when more people start using it?
• Can it be maintained and extended?
• Why does it sometimes produce errors?
• Is it storing or exposing data in ways it should not?
• What happens if the original AI tool changes or becomes unavailable?

We can help turn that prototype into reliable, secure and maintainable software.

Our developers can review the existing code, understand how it works, identify weaknesses and improve the structure of the application. We can address bugs, remove unnecessary complexity, improve performance, strengthen security and rebuild areas that need a more robust solution.

This is similar in spirit to our previous code polish service, but with an important difference: AI-assisted development gives clients a new way to express and explore their vision before approaching a software development studio.

You do not need to arrive with a perfect technical specification. You may already have a working prototype, a rough idea or a collection of experiments. We can use that as a starting point and apply our experience to make it ready for real users and real-world conditions.

Cutting through the hype

Our position is straightforward: AI agents have matured enough to become another tool in our development arsenal.

They are not a magic solution, and they are not a substitute for understanding software architecture, security, testing or the needs of the people who will use the finished product. Used badly, they can create problems just as quickly as they create code.

Used thoughtfully, however, they can help us explore ideas faster, reduce repetitive work, lower development costs and make custom software more accessible.

Our role is to help you cut through the hype and identify where these tools can provide genuine value. Sometimes that will mean building your project by hand. Sometimes it will mean using AI extensively under expert supervision. Sometimes the best starting point will be a prototype you have created yourself.

There is no single approach that is right for every client or every project. We will help you choose the right balance of speed, cost, control and craftsmanship for your particular needs.