Hingepoint.

Hingepoint combines human judgment with AI execution in a structured, event-driven development process. Humans define intent, shape solutions, make decisions, and remain accountable. AI accelerates implementation within those boundaries.

The bottleneck has moved. Your process hasn't.

AI made writing code fast, cheap and abundant. Organizing, verifying and owning that code is the new hard problem. Hingepoint is the event-driven framework for professional AI-assisted software engineering — proven in day-to-day business, free to read, and built to be adopted team by team.

Sound familiar?

• Generation got faster. Delivery did not.
• Reviews pile up. Quality and security wobble. Accountability blurs.
• Long waiting phases become the new bottleneck — and eat the efficiency gain.
• Nobody can quite say anymore who owns the code the AI wrote.

The cause is not the tools. Your established processes were built for human development speed — and every framework in history solved the bottleneck of its own era: Waterfall the cost of change, Scrum collaboration within teams. With generative AI the bottleneck has shifted once again. Workflows built for the old bottleneck cannot reach the new optimum.

The bottleneck is no longer creating software, but organizing and managing its development. That requires a new framework.

One flow. Under control.

Hingepoint treats AI as what it actually is: a new colleague with an exceptional profile — extremely fast, always available, yet prone to silent assumptions and confident errors. A process that recognizes only the strengths eventually fails on the weaknesses.

So every piece of work runs through one flow: think first, then generate — with Hingepoints as the built-in stopping points where work pauses for a human decision instead of running on a guess.

Work is not done when the AI stops typing. It is done when a human has explicitly accepted it.

Six principles hold it together:

Explicit over implicit

Assumptions, specifications and changes are documented before execution continues. Nothing changes silently.

Events over calendars

Synchronization happens when it is needed, not when a meeting is scheduled. No timeboxes, no status theater.

Ownership over speed

Software is not progress if no individual can accept accountability for its outcome, regardless of how quickly it was produced.

Accountability follows the context boundary

Human accountability ends where human understanding ends. Nobody can genuinely own a result beyond the context they actually hold.

Governance is built in

Governance and security are specified before implementation and validated as the solution evolves. "Not required" is an explicit decision, not an omission.

Tool agnostic

Principles, not products. No AI model, language, vendor or jurisdiction is prescribed.

Hingepoints

This is the part worth understanding, because the rest is arranged around it.

A Hingepoint is a planned, event-driven synchronization point at which automated execution pauses until a required decision, dependency, approval or external condition has been resolved.

It separates autonomous execution from conscious decision-making, and it exists to stop AI filling a relevant gap with an implicit assumption. When something is genuinely undecided, work stops and a human decides.

There are five kinds — a Decision to be made, a Dependency to be delivered, a Compliance question to be resolved, a Resource that has moved, or a Technical assumption that no longer holds. Each is recorded in a register with the condition to satisfy, who must supply it, and the timestamps that make waiting measurable.

Identifying one does not stop the work. A Hingepoint is placed where its condition becomes relevant, and work continues until that point is reached. Both humans and AI may raise one — which is precisely why AI must be able to register a Hingepoint and stop, rather than guess.

Every plan ends with one final Hingepoint: Acceptance, where the person responsible for the outcome confirms the result satisfies the intent.

The Tandem Manifesto

Before the framework there was an agreement. The Tandem Manifesto is a working agreement between software engineers and AI agents: fourteen recognitions and commitments, short enough to agree on and short enough to remember.

We move together. The human steers. Nothing changes silently.

It came out of the same practice the framework did, and it is the shorter way in — two pages rather than thirty-seven.

Where this came from

Between late 2024 and April 2026 we spent eighteen months transforming a development department into a team working with AI coding agents.

The problems we hit were not the ones we expected. Code appeared faster, and nobody felt accountable for it. Every developer used the agents differently, so one team ran several undeclared processes at once. Established practices did not fit: they assumed the constraint was writing the software.

We solved those problems for ourselves. The project was meant to stay internal — but the same questions kept arriving from other companies, in almost identical words. They had introduced coding agents expecting speed. They got either speed without ownership, or no speed at all, and in both cases a process that no longer described what people were actually doing.

So we formalized what we had built and made it freely available for anyone to adopt — including machine-readable working instructions, because a shared process that only the humans can read is not shared with the whole team.

The authors

Anastasia Galani

Co-author

Anastasia on LinkedIn

Ingo Rübe

Co-author

Ingo on LinkedIn

We have worked in software development and process engineering for decades, and we have seen a great deal of change.

Anastasia started as a software developer and advanced to Development Lead at Wincor Nixdorf. In 2005 she founded her own company, advising enterprises on software development processes and software quality assurance.

Ingo worked as Project Director for Axel Springer and as CTO of Burda, before moving fully into the open source world. There he joined the Board of Directors of the Drupal Association and founded KILT Protocol, a blockchain-based open source protocol for decentralised identity management.

We are both computer scientists, and we have worked through processes from Waterfall to Scrum and Kanban. We recognize the fundamental change AI brings to our industry, and we propose a new way of working.

Join the community

A freely available framework thrives through the practitioners using it. Input from different lines of business is what keeps it improving — and the community is where those observations get discussed.

Discord is for working conversations: questions, answers, contributions, issues. LinkedIn is for public ones. Neither is a sales channel — Hingepoint is tool-agnostic, and advertising will be removed.

Discord is open to everyone. You do not need a certificate to join, and you do not need to be using the framework yet. It also carries a separate channel for certified Hingepoint Engineers; access to that one is granted through the certificate platform.

Think first, generate second.