// tomko.ai / Haven Engineering
Haven Engineering
AI can write software. Knowing whether it did what we asked is a separate problem.
Haven Engineering is the engineering standard we use to build software at Tomko & Company. It defines how we specify work, implement it with AI, validate results and decide what is ready to release.
Overview
We developed Haven Engineering while building our own software with AI.
As our products became more complex, we needed a better way to manage the work. AI models could produce code quickly, but they could also misunderstand requirements, make assumptions and write tests that didn’t establish what we needed to know.
We wanted an engineering process that could work across different agents and models without losing track of decisions, requirements or evidence.
Haven Engineering is our approach to that problem. We define what needs to be built, establish how we’ll evaluate it, review the implementation independently and maintain a record of what was actually demonstrated.
The standard has evolved through our experience building software. When we encounter a problem in the engineering process, we investigate it and improve the method.
How it works
Haven Engineering organizes software development into four stages.
Decide
We establish what we’re building and why.
Product Strategy defines the direction. Release Design establishes the scope of a release, its intended capabilities and its boundaries. Discovery investigates uncertainties before implementation begins.
The goal is to make the important product decisions explicitly rather than leave them for an AI model to interpret during development.
Specify
We turn those decisions into requirements.
The Build Spec defines the implementation obligations. Semantic Contracts establish precise rules where necessary. The Validation Spec defines how we’ll determine whether the work meets its requirements.
These specifications are reviewed and finalized before implementation begins.
Build and check
AI agents implement the work within the boundaries established by the specifications.
The implementation is reviewed independently. Automated tests and other validation checks examine whether the required behavior was delivered.
When something fails, we correct the implementation or return to the appropriate specification. We don’t change a test merely to make an incorrect implementation pass.
Release and learn
Validation results are recorded separately from the requirements.
An accountable human decides whether the release meets its approval conditions, including any explicitly permitted limited release disposition.
Afterward, we document what worked, what failed and what we learned. Those findings help improve future releases and Haven Engineering itself.
Validation
Tests can pass without demonstrating that software meets its requirements. They might examine the wrong condition, miss part of the relevant data, or use expectations derived from the implementation being tested.
We establish validation requirements before implementation and independently review the results.
Our validation approach distinguishes between:
- Requirements: What the software must do.
- Evidence: What was actually examined and demonstrated.
- Results: Which requirements passed, failed or remain unverified.
- Approval: Whether the available evidence supports releasing the software.
Validation cannot eliminate every defect. It should make clear what has been demonstrated, what remains uncertain and why a release decision is justified.
Execution routes
Haven Engineering 4.0 supports two approaches to implementation.
Both follow the same principles: product requirements must be settled before implementation, work must remain within defined boundaries, and validation and release decisions remain subject to independent review and human authority.
They differ in how much implementation detail is specified in advance.
This is the original and default approach.
Before implementation begins, we define much of the technical design, including architecture, implementation tasks, interfaces and validation requirements.
AI agents implement the work within those specifications. Changes to binding decisions return to their owners.
This approach works well when detailed implementation planning is appropriate.
This approach allows greater flexibility in how implementation proceeds.
Rather than prescribing every technical step, we establish a defined objective and an Execution Contract. The contract specifies the permitted work, evidence requirements, acceptance conditions and boundaries that cannot be crossed.
Within that contract, AI agents can investigate and revise implementation details as they work.
This route is available only for qualifying work under the standard’s defined conditions. It does not permit agents to change product requirements or bypass validation and approval.
The distinction is simple: we can give AI more freedom in how it builds software without giving it authority to decide what the software should be.
Limits
Haven Engineering is an engineering standard, not a guarantee of software correctness.
Following a process does not establish that every implementation is correct. Each release must be evaluated against its own requirements and evidence.
Independent review and validation help us identify problems and understand what has been demonstrated. They cannot prove that every possible defect has been found.
The additional flexibility introduced in version 4.0 is deliberately restricted to qualifying work. It does not establish that the approach is appropriate for every product or engineering problem.
History
Established the original engineering principles, specification-driven development and human release authority.
Strengthened independent review and human validation requirements following lessons from Civil development.
Separated validation requirements from validation results and formalized additional discovery and retrospective practices.
Strengthened evidence requirements, including the need for automated checks to demonstrate that they examine the right conditions and can detect relevant failures.
Introduced objective-bounded execution alongside the existing specified-execution approach, while preserving the requirements for review, validation and human approval.