Back to the basics in the Age of AI: Why understanding the real-world business still comes first

Summarize this article with AI

Software is cheaper to write than ever. AI assistants can produce a working screen in minutes, and a prototype that once took a sprint can now take an afternoon. Yet the hardest problems in software delivery have barely changed. Projects still miss deadlines, systems still get rebuilt a year after launch, and users still keep their own spreadsheets on the side because “the system doesn’t really work the way we do.”

The reason lies in what software actually is. Every application is a representation: a model of how a business works, what it deals with, and what its people want to achieve, written in a language a machine can execute. Code is only the last step of that translation. If the understanding behind it is wrong, the code faithfully reproduces the mistake, however well it is written.

In the latest episode of The Performance-led AI Log, Nam Ly, our BA Lead, takes a step back to the work that should happen before the first line of code. He introduces six questions that help teams understand how a business actually works, and explores how AI can accelerate that process without replacing the human conversations and judgment it depends on. 

Figure 1: Software is a chain of translations. A mistake in the first step travels all the way to the last
Figure 1: Software is a chain of translations. A mistake in the first step travels all the way to the last

About Nam Ly 

Nam Ly is BA Lead at Synodus, where he leads a team of business analysts on large-scale government and enterprise systems. He studied biology at Hanoi-Amsterdam High School for the Gifted and graduated in Information Systems from the Posts and Telecommunications Institute of Technology (PTIT), then moved from technical support into business analysis, where he has spent around five years on outsourcing projects. He is drawn to process and order, and to finding the universal patterns behind how the world works, which is what business analysis now lets him do every day. Self-taught and obsessed with UX/UI, he believes a system is only as good as the experience of the people using it. He holds the PMP certification and is pursuing CBAP.

The shortcut we all know

Much of the outsourcing industry, including in Vietnam where we work, follows a familiar pattern. A client sends a list of features and a few screen mock-ups. The team estimates, builds, and ships as quickly as possible. Deep analysis of how the client’s business actually works is treated as a cost to minimize, or something to sort out later during testing. Agile is often cited to justify this: development starts on day one, and “working software over comprehensive documentation” becomes a reason to skip analysis. Yet the same manifesto asks business people and developers to work together daily, which a remote team working from a feature list rarely does.

We understand why. Speed is what clients ask for, and analysis is hard to bill. We have worked this way ourselves. But the cost does not disappear. It moves downstream, into rework, change requests, and long acceptance cycles, where every misunderstanding has to be found, argued over, and fixed in something that is already built.

Where software actually fails

When we analyzed the defects from one of our own large projects, specified the conventional way, around two in three did not come from faulty code. They came from the specifications. The developers built exactly what was written, and what was written was incomplete, contradicted itself, or was simply wrong about how the business worked.

The first two are problems of writing, and discipline can fix them. The third is different. No amount of careful writing helps when the understanding behind the document is wrong.

The patterns are familiar to anyone who has run a project. A rule nobody wrote down, so each screen enforces it differently. A status that means one thing to operations and another to finance. An edge case everyone handles by hand, so nobody thought to mention it. A step that normally waits three days for approval, quietly turned into a button that “just submits.”

None of these can be solved by writing better code. The answers rarely live in one document or with one person. The business owner understands the purpose, the operations team knows the exceptions, and the finance team knows the rules that cannot be broken. Sometimes they do not even agree on what the same term means. Someone has to bring those perspectives together, ask the uncomfortable questions, and resolve the contradictions before they become software behavior.

How the pioneers turned the world into software

Figure 2: Seventy years of better ways to describe the world before translating it into code
Figure 2: Seventy years of better ways to describe the world before translating it into code 

It was not always this way. In 1951, the British catering company J. Lyons & Co. began using LEO I for routine business computing. Its team had spent years studying how the company actually operated, from orders and stock to payroll. The computer came second. Understanding the business came first.

COBOL, at the end of the 1950s, was designed around English-like statements so that business people could read what the programs did. In 1968, a NATO conference popularized the term “software engineering” in response to a “software crisis” of large systems delivered late, over budget, or not at all. In 1970, Winston Royce published the paper later associated with the waterfall model, though he actually warned against building without enough design and early validation.

The following decades produced many of the modeling approaches still used today: Peter Chen’s entity-relationship model in 1976, David Harel’s statecharts and John Zachman’s architecture framework in 1987, Ivar Jacobson’s use cases, and later Eric Evans’s Domain-Driven Design. Japanese system integrators, meanwhile, built large systems on disciplined design documents that traced every screen back to business requirements.

Not all of them were invented for business software, but each gave us a more precise way to describe how something works before committing it to code. The Agile Manifesto of 2001 rightly pushed back against documentation for its own sake; it never asked anyone to stop understanding the business.

Six layers of a business

None of what follows is new. Standards such as ISO/IEC/IEEE 29148 and Japan’s Common Frame have long separated business requirements from system design, and every technique below is decades old. What is new is the context. As AI takes over more of the labor in software delivery, with people kept in the loop, it is leading us back to basics: to the business itself, and to the root problem the software is meant to solve.

Our team organizes that understanding into six layers, each answering a question every organization has an answer to, whether or not anyone has written it down. Each layer borrows a familiar notation.

Figure 3: Six layers of a business

What are we solving, for whom, under which mandate, and how will we know it worked? 

Artifact: a business requirements document (BRD). 

2. How: Business processes

How does work move from a starting event to a result, and where does it wait? 

Artifact: BPMN process models. 

3. What: The domain

Which things does the business deal with, and how do they relate? 

Artifact: conceptual and logical ERDs, with a glossary.

4. Who: Actors and what they do

Which people and systems take part, and what may each of them do? 

Artifact: UML actor and use case diagrams. 

5. When: lifecycles

How does each important thing change over time, and who may move it from one state to the next? 

Artifact: state machines.

6. Rules: the constraints that drive the business to its goals

What must always hold true, whichever screen or integration handles the data?

Artifact: a business rule catalog and decision tables.

These notations are borrowed from engineering, because they are precise and both people and machines can check them. What they describe is purely the business: no architecture, no database design, no technology choices. That is the approach we are building at Synodus. Only then do we describe the software: use cases, screens, and prototypes, each pointing back to the part of the business it represents. Whatever a client provides, from laws and forms to meeting notes, ends up in the same structure.

Why not just prototype and iterate?

It is a fair question, and Fred Brooks asked it first. In his 1986 essay “No Silver Bullet,” he argued that clients cannot fully specify what they want in advance, and recommended rapid prototyping and step-by-step refinement. With AI, prototypes are cheaper than ever, and we rely on them: they are still the best way to check screens, flows, and the experience of the people who will use the system.

But a prototype shows only what is on the screen. It does not reveal that two regulations conflict, that a rule applies once a year, or that nobody has decided who may approve an exception. And on a fixed-scope contract, every iteration after sign-off is a change request. So we do both: model the business first, then prototype against that model.

What AI changes, and what it does not

For decades, the main argument against this level of analysis was cost. Describing a business and designing from it meant months of interviews and diagrams drawn by hand, and the documents went stale soon after sign-off. AI changes that. In our approach, AI assistants read regulations, forms, and meeting notes, draft the six layers, cross-check them against one another, and ask the questions an analyst would ask when something is missing or contradictory. When new information arrives, they update the affected layers, so the business model stays alive for the whole project instead of being written once and forgotten. The specification behind it, from use cases to screens, can then be regenerated from that model, with people reviewing every step.

We also learned the limits of AI the hard way. When our teams first used AI to generate code from specifications, the work became noticeably faster, and one kind of defect almost disappeared: code that did not match the specification. We did not track this formally, but our engineers estimate those bugs fell by close to 90 percent. AI is very good at building what it is told to build. Bugs that came from misunderstanding the business barely moved. They now make up most of what is left. Where the understanding was wrong, we simply built the wrong thing sooner.

Figure 4: What our teams observed after using AI to generate code from specifications. Team observations, not measured statistics.
Figure 4: What our teams observed after using AI to generate code from specifications. Team observations, not measured statistics. 

AI is very good at building what it is told to build. It did nothing to make what we told it more correct. 

That is the part no AI changes. AI can help us describe a business; it cannot establish what is true about it. It cannot tell whether a document matches practice, which reading of an ambiguous policy is correct, or which trade-off the business will accept. Those answers come from people talking to each other: an analyst sitting with the people who do the work, asking why, and helping leaders and staff agree on how things should run. Sometimes the most important discovery is not a missing requirement, but a disagreement nobody knew existed.

AI does not make business analysis optional. It makes doing it properly affordable.

What this means for leaders

Given the nature of our work, this approach is not optional for us. Our projects are large and often in the public sector, where requirements come from a dense body of laws and regulations, stakeholders number in dozens, the work runs for years, and every change after sign-off becomes a formal change request. Raising quality and efficiency at that scale meant building an AI-assisted framework that keeps all six layers of a client’s business in one living model, one that outlasts the meetings and the people that produced it.

On smaller projects we run a lighter version: a short brief, the main processes, a shared glossary, and a list of rules, with state machines only where something has a real lifecycle. With fewer stakeholders and rules, clients can validate prototypes directly, and a misunderstanding costs days rather than months to fix. A full model there would cost more than the mistakes it prevents.

Figure 5: The full six-layer model where regulation and scale demand it; a lighter version where a misunderstanding costs days, not months.
Figure 5: The full six-layer model where regulation and scale demand it; a lighter version where a misunderstanding costs days, not months.

An approach that hides its costs is not worth trusting, so here are ours. 

What it gives

  • Problems surface earlier: Missing requirements, conflicting rules, and unclear responsibilities are found while they are still on paper, not in a released product. 
  • One shared language: Business owners, analysts, developers, and testers refer to the same things in the same way. 
  • Consistent rules: Constraints defined once are enforced the same way across screens, integrations, and reports. 
  • Change you can assess: When a law or policy changes, the links between rules and system behavior show what needs review and what it will cost. 

What it costs

  • An upfront investment: Even with AI, modeling a business takes time before users see the first working screen. 
  • Stronger analysts: The role shifts from recording feature requests to understanding how the business works and challenging what does not add up. 
  • Time from your people: Models cannot validate themselves. The people who run the business still need to review prototypes and answer questions. 

Three questions to ask your own team

  • Of last quarter’s defects, how many came from code that did not match the specification, and how many from a specification that did not match the business? 
  • When two departments use the same word, where is its agreed meaning written down? 
  • When a regulation changes, how long does it take to list every rule and screen it affects?

What we know so far, and what we do not. This approach is young. On the first small systems where we modeled the business before specifying anything, such as class management and small-scale inventory, our teams saw fewer bugs caused by misunderstanding. We do not have numbers yet. The bugs that remained came from analysis that did not go deep enough and questions nobody asked, which is work only people can do. We are now tracking defects by origin, change requests after sign-off, and analysis effort, on projects with and without the six layers. 

Understanding somes first

The first business computer was built by people who studied the business before they built the machine. In that same 1986 essay, Brooks wrote that “the hardest single part of building a software system is deciding precisely what to build.” Forty years and one AI revolution later, the coding has become almost free. The hardest part has not moved. 

Code is cheap now. Understanding never was. 

How useful was this post?

Click on a star to rate it!

Average rating / 5. Vote count:

No votes so far! Be the first to rate this post.

Meet our author

Jenny Duong
Jenny Duong
Jenny Duong is a Content Marketing Strategist focused on thought leadership in custom software development and digital transformation. With over five years of experience in B2B technology marketing, she helps software companies articulate complex engineering, product, and delivery concepts into strategic insights for executives and decision-makers. Her writing explores how custom software creates long-term business value, mitigates technical risk, and enables scalable growth in an increasingly AI-driven and regulated landscape.
Recent posts
Subscribe to newsletter & Get update and news
We use cookies to bring the best personalized experience for you. By clicking “Accept” below, you agree to our use of cookies as described in the Cookie policy