THE FRAMEWORK
AI agents write the code. Senior engineers decide what ships.
Anyone can generate an application in an afternoon now. Knowing what to build, checking that it is right, and answering for it next year is still hard. dotconnector is the delivery process we built for that part. It carries twenty years of our experience building software for clients, the agents do the work, and a person opens every gate.
WHERE IT COMES FROM
Twenty years of building software, and the agents inherit all of it.
Across hundreds of projects for clients, we learned when a decision has to be recorded, what a review has to catch, and what must never reach production without a person signing it off. We wrote that experience down precisely enough for an AI agent to follow it. The models supply the speed. The experience supplies the judgment.
WHAT IT IS
The full software lifecycle, with the agents working inside it.
Describing what you want and prompting until it seems to work is what people now call vibe coding. It makes a fine prototype and a poor foundation for a business, because nobody can say why the system is shaped the way it is or what was checked before it shipped. dotconnector runs the same lifecycle we would run with a senior team, and the agents work inside it.
- Requirements come first, written as business outcomes with acceptance criteria, before anything is designed.
- Architecture is decided before code, and every significant decision is recorded with its reasoning.
- Every change is one reviewed pull request with its tests, tied to one task, and a person merges it.
- Your constraints on infrastructure, data and compliance are hard rules the agents cannot trade away.
HOW IT WORKS
Four phases, and a senior engineer opens the gate at the end of each.
Four phases in sequence: Understand, Design, Build and Harden. A gate follows each phase, where a senior engineer accepts the phase's output or sends it back. Three loops send work back: review findings return to the build, audit findings from Harden become new build tasks, and drift found while building returns to the design as a controlled change to the plan.
-
Understand
Your workshop notes, transcripts, emails and briefs become structured requirements, each with acceptance criteria and the reason it matters. We review them with you before anything is designed.
-
Design
The agents propose the architecture, record each decision with its reasoning, design the interface and break the work into tasks in dependency order. A senior engineer accepts each step or sends it back.
-
Build
One task at a time, an agent branches, implements, writes the tests and opens a pull request. A second agent reviews it against the task's contract, the loop repeats until the review is clean, and a person merges. Each finished requirement is then walked against its own acceptance criteria.
-
Harden
With the whole system in place, four audits run: code quality, security, coverage of the requirements and conformance to the architecture. A person confirms each finding before it becomes a task.
The dashed loops are where we expect reality to push back. Review findings return to the build. Audit findings become new tasks. When building reveals that the plan was wrong, the agents flag it and the change goes back through the design with a person's confirmation.
REVIEWED ON EVERY LEVEL
Four levels of review, each by a machine and then by a person.
- Every change CI runs the tests, lint and build. An independent agent reviews the pull request against the task's contract and for code quality. A senior engineer merges, or sends it back.
- Every requirement The running application is walked against the requirement's acceptance criteria, with the evidence posted. A person accepts it or returns it to the build.
- Every plan Requirements, architecture, decisions, interface design, task breakdown and deployment plan each stop at a gate a senior engineer opens.
- The whole system Quality, security, coverage and conformance audits, plus static analysis and dependency and container scans on a schedule. A person triages every finding before it becomes work.
The agent that reviews the code is never the agent that wrote it, and it has no power to merge. The people who approve carry the responsibility, and the process hands them the evidence to carry it.
DOCUMENTED AS IT IS BUILT
Documentation is what each step leaves behind.
The pipeline cannot move forward without writing things down, because the next step reads what the last one wrote. Requirements live in Linear with the input they came from. Every architectural choice is an Architecture Decision Record, dated and superseded rather than rewritten. Every pull request links to its task and carries its review findings. Pick any line of code and you can follow it to the meeting where the need was first raised. A new engineer, an auditor or a buyer gets the answer to "why is it like this?" in minutes.
A PROCESS THAT IMPROVES ITSELF
We measure the pipeline on every project, and we keep it current.
Because every step runs through GitHub, Linear and CI, each project leaves a full trace: how long each phase took, how many review rounds a change needed, where work waited for a decision. We read that trace across projects and change the pipeline on evidence, moving a check earlier or removing a step that was not earning its cost. The tools underneath change monthly, so we track the AI tooling market as part of the job and adopt what proves itself against our own data. The process you get is the current one.
WHAT IT MEANS FOR YOU
The calendar only stops at the gates.
Agents move from requirement to design to code without waiting on a hand-off between people. Work pauses where a decision is needed, and a senior engineer is there to make it.
Every level is reviewed by a machine and then a person.
Every change, every requirement, every plan and the whole system are checked against written criteria. What reaches you has been looked at twice.
Your constraints are rules the agents cannot bend.
Security is checked at the pull request, in CI and across the whole system. Nothing merges or ships without a person's sign-off, and every decision is on record.
This process is what makes the YSaaS terms possible. See the offer in detail →