Modern software projects often fail because implementation begins before the problem is fully understood. Requirements change, terminology becomes inconsistent, and teams spend more time correcting misunderstandings than building useful software.
The Thebe Space Design Process addresses this by separating software engineering into six distinct stages. Each stage produces clear outputs that become the inputs to the next, reducing ambiguity and making the implementation predictable.
Rather than asking AI to “build an application”, the process produces a complete engineering specification that AI can implement with confidence while humans remain responsible for the design and validation.
Understand the Problem
Everything starts with understanding the operational problem rather than thinking about technology.
The objective is to clearly define:
- the measurable problem
- the desired outcome
- project goals
- project scope
- constraints
- assumptions
- user stories
Technology choices are intentionally delayed until the problem is understood.
A good problem statement should allow anyone reading it to understand why the software is being built before discussing how it will be implemented.
Benefits
- Solves the correct problem instead of the most obvious one.
- Creates measurable success criteria.
- Gives everyone a shared understanding of the project.
- Reduces expensive changes later in development.
Model the Language
Every industry already has its own language.
Engineers, operators, doctors, pilots and military personnel all use established terminology to describe their work. Rather than inventing new software terminology, the design process captures and formalises the language already used by subject matter experts.
This includes identifying:
- concepts
- actors
- things
- places
- activities
- events
- relationships
- verbs that operate on nouns
This creates a shared vocabulary that is used consistently throughout the project.
The same language appears in:
- specifications
- architecture
- source code
- APIs
- user interfaces
- documentation
- logs
- AI prompts
Benefits
- Eliminates inconsistent terminology.
- Makes software easier to understand.
- Produces readable APIs and code.
- Allows domain experts to validate the design before implementation.
- Gives AI precise language instead of ambiguous descriptions.
Design the Solution
Once the language is understood, the software architecture becomes much easier to define.
Nouns naturally become:
- objects
- entities
- resources
- services
- data models
Verb–noun pairs become operations.
User stories become workflows.
Relationships become navigation and integration points.
Instead of beginning with databases or frameworks, the architecture emerges naturally from the domain itself.
Benefits
- Produces software that reflects the real world.
- Keeps the architecture consistent.
- Separates responsibilities cleanly.
- Simplifies implementation.
- Makes future changes easier because the design is based on the problem rather than the technology.
Write the Specification
Only after the design is complete is the implementation specified.
The specification defines:
- implementation technology
- architecture
- interfaces
- data structures
- runtime behaviour
- deployment
- security
- testing
The objective is to remove as much guesswork as possible before implementation begins.
AI performs best when given complete, precise instructions rather than broad requests.
Benefits
- Reduces implementation errors.
- Produces repeatable engineering outcomes.
- Enables parallel development.
- Creates documentation that remains useful after the software is delivered.
- Makes implementation largely deterministic.
AI Implements It
Once the specification exists, AI becomes a powerful engineering tool.
Rather than asking AI to invent the solution, it is asked to implement a design that has already been reviewed and approved.
AI can rapidly produce:
- source code
- unit tests
- documentation
- configuration
- deployment scripts
- boilerplate
- repetitive implementation work
Human engineers remain responsible for architectural decisions and technical judgement.
Benefits
- Significantly faster implementation.
- Consistent coding style.
- Reduced manual effort.
- Engineers spend more time designing and less time writing repetitive code.
- AI works from a clear specification instead of making assumptions.
Humans Validate the Outcome
Implementation is not the end of the project.
The completed software is validated against the original objectives.
The key question is simple:
Does this solve the original problem?
Validation compares the implementation with:
- the original problem statement
- project goals
- user stories
- architecture
- specifications
- operational requirements
This ensures the software is both technically correct and operationally useful.
Benefits
- Prevents “technically correct but operationally wrong” software.
- Confirms that user needs have been met.
- Provides confidence before deployment.
- Creates a feedback loop for continuous improvement.
Why this approach?
Traditional software development often jumps quickly into implementation, making architecture evolve as code is written. While this can work well for small projects, it becomes increasingly difficult as systems grow in size, involve multiple organisations or operate in mission-critical environments.
The Thebe Space Design Process takes the opposite approach.
It invests more effort in understanding, modelling and designing the system before implementation begins. Once those foundations are in place, implementation becomes significantly faster, more predictable and easier to automate.
AI doesn’t replace software engineering in this process—it amplifies it.
Human engineers remain responsible for understanding the problem, defining the language, designing the architecture and validating the outcome. AI accelerates the implementation of those decisions.
The result is software that is easier to understand, easier to maintain and better aligned with the operational problem it was built to solve.