Apex

The value of AI assistance in software engineering is conditional on the process that surrounds it, rather than being a property of the model alone.

A process framework for using AI across the software lifecycle with people in control, and Apex, the web app that implements it.

Degree
MSc in Computer Science and Engineering, Instituto Superior Técnico, Universidade de Lisboa
Defended
23 October 2026
Grade
17/20
Full thesis record
Title
Governed Human-AI Collaboration Across the Software Development Lifecycle: A Process Framework and Its Reference Implementation
Supervisor
Prof. Miguel Mira da Silva
Committee
Prof. Helena Galhardas (chair), Prof. Ademar Aguiar (member)
Submitted
7 October 2026
Method
Systematic Literature Review (646 articles) + Design Science Research Methodology

In short

AI coding tools have been adopted faster than any method for using them well. This thesis proposes a process framework that treats AI as a bounded, validated and traced collaborator across the whole software lifecycle, and builds Apex to show it working.

Full abstract

Generative Artificial Intelligence and Large Language Models have moved from autocomplete assistants to active contributors across the Software Development Life Cycle, enabling development in which practitioners express requirements in natural language and supervise the resulting artefacts. Adoption has outpaced method. A Systematic Literature Review over 646 articles confirms substantial benefits alongside recurring risks in reliability, security, traceability and accountability, and identifies the absence of structured, repeatable guidance for integrating these tools into professional workflows as the field's central unresolved problem. Therefore, value is conditional on process, not on model capability alone. This dissertation addresses that gap through the Design Science Research Methodology. It proposes a process-oriented framework for governed Human-AI collaboration treating AI systems as first-class collaborators whose contributions must be bounded, validated and traced. The framework defines lifecycle phases with phase-specific quality gates, responsibilities expressed as functions rather than job titles, and governance metrics, anchored by a persistent versioned specification linking every generated artefact to its originating requirement. It is instantiated as Apex, a web application operationalising each phase, gate and artefact against a real project management backend. Evaluation combines application in a real project, standardised usability and workload instruments, interviews with practitioners and an Agile expert, and an analytical assessment against criteria set in advance. The contribution is an evidence-grounded process model allowing organisations to adopt AI assistance without surrendering oversight of software quality, security and accountability.

The problem

  • 84% use, 29% trust Developers using or planning to use AI tools rose to 84% (from 76%), while the share trusting the accuracy of that output fell from 40% to 29%. More respondents actively distrust AI output (46%) than trust it (33%). (Stack Overflow, 2025 Developer Survey: AI)

  • 61% correct, 10.5% secure Benchmarked on real-world tasks, a leading coding agent produced functionally correct solutions 61% of the time, but only 10.5% of them were secure. (Zhao et al., 2025, “Is Vibe Coding Safe?” (preprint))

  • +98% PRs, +91% review time Across 1,255 teams, high AI adoption came with 98% more pull requests merged but 91% longer review times, and no significant correlation with delivery outcomes. (Faros AI, The AI Productivity Paradox Report 2025)

Waterfall, Scrum, Kanban and the Agile Manifesto were designed for teams in which every contributor is human. They have no explicit structure for governing AI participation, bounding the context a model may act upon, or allocating responsibility over generated artefacts.

The framework

The framework is a method: phases, hats, artefacts and decision rules that prescribe how a team organises AI participation across the lifecycle. It describes process and does not depend on any tool. A Strategic Alignment stage decides whether a Unit of Work should exist at all. Six phases follow, each consuming the output of the one before and closed by a gate with a named owning hat. Failure never discards work: it returns it to a named earlier phase with the evidence attached.

Two terms recur below. A Bolt is the smallest unit of execution: the implementation of one task within a User Story. The Trio is the Product Owner, Tech Lead and Design Lead hats together, and it owns Discovery and Design.

The framework’s six lifecycle phasesStrategic Alignment, then six sequential phases, each closed by a quality gate. Maintenance has three governed loop-backs: production defect to Implementation, specification gap to Design, business deviation to Discovery. Every phase anchors to a versioned specification.persistent, versioned specification: global + local layersStrategicAlignmentP1Discovery &RequirementsP2Design,Prototyping &ArchitectureP3ImplementationP4TestingP5DeploymentP6Maintenancegateproduction defect (Fix-Bolt)specification gapbusiness deviation
The six lifecycle phases, their gates and the three governed loop-backs out of Maintenance
PhaseRole of AIExit control
P1 Discovery & RequirementsDrafts stories, compiles approved scenarios into GherkinDiscovery Gate (the Trio)
P2 Design, Prototyping & ArchitectureProposes UI structure and a technical specificationDesign Gate (Design Lead, Tech Lead)
P3 ImplementationGenerates and refactors code inside a BoltImplementation Gate (Developer)
P4 TestingDrafts end-to-end BDD scripts from locked GherkinTesting Gate (QA)
P5 DeploymentGenerates the infrastructure delta only when requiredDeployment Gate (Deploying hat)
P6 MaintenanceReconstructs a narrow context to diagnose one signalDiagnostic firewall, governed loop-back

Hats

Every role is a hat: a function someone on the team has to perform. One individual may wear several; on a small team an unfilled hat falls to whoever does the adjacent work. Logistics authority (Bolt Master) is kept separate from technical authority (Tech Lead), and every gate is attached to a named function.

Spec-Anchored Continuity

Every AI-generated artefact carries forward the context of previously validated phases through a persistent, versioned specification: a global layer (architecture, stack decisions, security policy) and a local layer (a story’s locked Gherkin and technical specification). Narrowing what a model can see is a control in its own right.

Three governance metrics

Bolt Cycle Time
The elapsed time from a task being pulled as a Bolt to its completion, measured at task level to isolate execution from queueing, review and gate transitions.
Context Traceability Rate
The proportion of deployed Bolts and stories whose artefacts can be traced through the locked specifications to their originating Unit of Work.
AI Defect Escape Rate
The proportion of production defects originating in AI-generated logic that passed the Testing Gate. Apex can only observe it through a named proxy.

Reference implementation

A coding agent speeds up writing code. Apex checks that the code still meets the requirement it was written for. It is a split full-stack app, a Next.js/TypeScript frontend and a Python/FastAPI backend over a typed REST API, that runs every phase, gate and artefact against a real project-management backend (Taiga or Plane) and keeps context in human-readable, versioned spec files.

  • Phased workflow with gates

    Transitions are gated on content: no implementation without a locked Gherkin spec, no deploy without a QA sign-off or a green CI run, enforced server-side.

  • Traceability graph

    One interactive derivation graph per project (epic → story → Gherkin → design → tasks → tests → deploy), built from the story index with no AI involved.

  • Governance analytics

    Bolt Cycle Time, Context Traceability Rate and AI Defect Escape Rate, computed from the project and exportable as Markdown or CSV.

  • Human-in-the-loop guardrails

    Multi-model cross-check, diff-on-regenerate, a decision log and an optional “Guide the AI” steer on every generative step.

  • Autopilot

    Runs the full Phases 1–5 pipeline end to end in the background.

  • Spec-anchored storage

    Workflow state lives in versioned, human-readable Markdown context files and a story index.

Component diagram: Next.js frontend with React Query, Zustand and a PM adapter calls a FastAPI backend whose phase routers reach a ContextService and a guarded egress layer; specs are stored as Markdown plus a story index on local disk or Azure File Share.
Apex architecture, part 1 of 2: internal request path and the specification store
Component diagram: the phase routers and PM adapter call a FastAPI egress layer of Taiga and Plane proxies, ai_engine provider routing, a Figma proxy and GitHub fetch, actions and webhook handlers. These reach Taiga through a Cloudflare relay, Plane, Anthropic Claude, OpenAI, Google Gemini, the Figma REST API and the GitHub REST API. github-browser.ts calls GitHub directly from the browser.
Apex architecture, part 2 of 2: the guarded egress boundary and the external services it reaches
Deployment Gate screen with an infra delta verdict, a deploy pack, a traceability matrix with three passing scenarios, and two unchecked human gatekeeper sign-offs.
Deployment Gate in Apex: delta verdict, deploy pack, traceability matrix and the two human sign-offs

The demonstration, phase by phase

Screens from the dissertation’s demonstration chapter, captured while Apex governed the Outfolio build.

Engineering

  • 1,171commits
  • 1,640backend tests
  • 318frontend unit tests
  • 24E2E cases

Stack

Backend
Python 3.12, FastAPI, Pydantic v2, LangChain
Frontend
Next.js 15, TypeScript, React Query, Zustand, Tailwind CSS
Platform
Docker, GitHub Actions, Azure Container Apps, Redis
PM backend
Taiga, Plane

Demonstration

The framework was carried from Strategic Alignment to a deployed product over nine calendar days, growing from six pre-committed epics to nine epics and 54 stories, none abandoned, with all three loop-back routes exercised more than once.

Context Traceability Rate
92.6%
Spec Conformance mean
98.65%
AI Defect Escape Rate
1.85%
Outfolio home page with the product title, account actions and a row of published project highlights.
Outfolio dashboard: the product built for the lifecycle demonstration

Evaluation and results

MeasureResult
Governance constructs realised10 of 12 as specified, 1 as a named proxy, 1 partially
Task-based sessions13
Perceived workload (Raw NASA-TLX)21.5 / 100 (low)
Perceived usability (SUS)56.73, grade D (below published norm)
Design criteria (5, fixed in advance)2 met, 3 partially met, 0 not met
Demonstration (Outfolio)9 days, 9 epics, 54 stories, CTR 92.6%, Spec conformance 98.65%, AI defect escape 1.85%

Limitations found in the evaluation

Low workload, below-norm usability

Across thirteen sessions, perceived workload was low (Raw NASA-TLX 21.5/100) while usability sat below the published corpus mean (SUS 56.73, grade D). Most of the difficulty came at first contact with a dense interface: a practitioner who already knows where they are finds it undemanding, and the tool does too little to get newcomers to that point.

A gate that could be passed by a stale suite

The Outfolio demonstration surfaced a Testing Gate passable by a suite that had stopped measuring the system it tested.

The partner-organisation demonstration did not happen

An independent partner organisation was pursued and abandoned: a mid-project migration from Taiga to Plane delayed it while Apex’s adapter was built, and outreach afterwards never led to a scheduled engagement. The framework has still not been run by a team that did not design it.

History

The app and the dissertation share one git history across six months, so the way the work was built can be read back out of it: when the stack changed, when the thesis started pulling commits away from the app, and which bugs were only found by writing about the tool.

  • 1,171commits
  • 186days, first to last commit
  • 199commits on the dissertation
  • 5feature branches merged
  • 47busiest day (18 Jul)
Apex commit history as a git graphFrom 24 April to 27 October 2026: the main line with weekly commit volume, five feature branches merged back into it, and the dissertation track from 4 August. Numbered markers match the list below.MayJunJulAugSepOctmainthesisreflex-migration, 13fastapi-nextjs, 23jira-integration, 4ui-revamp, 7plane.so-integration, 235 commits35 commits82 commits81 commits80 commits61 commits67 commits115 commits67 commits85 commits41 commits30 commits88 commits20 commits26 commits12 commits17 commits10 commits4 commits1 commits37 commits7 commits1 commits11 commits12 commits19 commits6 commits26 commits6 commits50 commits1 commits24 commits37 commits7 commits12345678910
  1. first commit (bolt, Streamlit)
  2. renamed Apex
  3. governance analytics
  4. Figma integration
  5. design system
  6. Outfolio chosen
  7. dissertation scaffolded
  8. evaluation data complete
  9. submitted
  10. defended, 17/20
Commit graph: main, the five merged feature branches and the dissertation track. Dot size is commits per week.

Commits per day

AprMayJunJulAugSepOctMonWedFri2026-04-19: 02026-04-20: 02026-04-21: 02026-04-22: 02026-04-23: 02026-04-24: 22026-04-25: 02026-04-26: 02026-04-27: 02026-04-28: 22026-04-29: 12026-04-30: 02026-05-01: 02026-05-02: 02026-05-03: 12026-05-04: 202026-05-05: 62026-05-06: 12026-05-07: 72026-05-08: 72026-05-09: 112026-05-10: 32026-05-11: 362026-05-12: 202026-05-13: 22026-05-14: 32026-05-15: 172026-05-16: 02026-05-17: 42026-05-18: 202026-05-19: 282026-05-20: 12026-05-21: 112026-05-22: 232026-05-23: 292026-05-24: 02026-05-25: 02026-05-26: 202026-05-27: 12026-05-28: 72026-05-29: 102026-05-30: 02026-05-31: 02026-06-01: 72026-06-02: 112026-06-03: 212026-06-04: 122026-06-05: 82026-06-06: 52026-06-07: 52026-06-08: 152026-06-09: 162026-06-10: 72026-06-11: 112026-06-12: 252026-06-13: 82026-06-14: 202026-06-15: 182026-06-16: 132026-06-17: 172026-06-18: 142026-06-19: 122026-06-20: 172026-06-21: 102026-06-22: 132026-06-23: 72026-06-24: 22026-06-25: 62026-06-26: 02026-06-27: 162026-06-28: 72026-06-29: 82026-06-30: 272026-07-01: 222026-07-02: 52026-07-03: 62026-07-04: 42026-07-05: 182026-07-06: 32026-07-07: 02026-07-08: 52026-07-09: 52026-07-10: 42026-07-11: 42026-07-12: 132026-07-13: 62026-07-14: 02026-07-15: 32026-07-16: 02026-07-17: 52026-07-18: 472026-07-19: 92026-07-20: 112026-07-21: 112026-07-22: 12026-07-23: 42026-07-24: 22026-07-25: 112026-07-26: 52026-07-27: 22026-07-28: 02026-07-29: 02026-07-30: 02026-07-31: 02026-08-01: 02026-08-02: 02026-08-03: 02026-08-04: 102026-08-05: 212026-08-06: 62026-08-07: 12026-08-08: 32026-08-09: 02026-08-10: 42026-08-11: 112026-08-12: 52026-08-13: 02026-08-14: 02026-08-15: 02026-08-16: 02026-08-17: 12026-08-18: 22026-08-19: 252026-08-20: 82026-08-21: 52026-08-22: 02026-08-23: 02026-08-24: 12026-08-25: 02026-08-26: 02026-08-27: 02026-08-28: 92026-08-29: 02026-08-30: 32026-08-31: 102026-09-01: 122026-09-02: 12026-09-03: 12026-09-04: 12026-09-05: 02026-09-06: 02026-09-07: 12026-09-08: 22026-09-09: 02026-09-10: 62026-09-11: 02026-09-12: 02026-09-13: 202026-09-14: 292026-09-15: 22026-09-16: 02026-09-17: 02026-09-18: 62026-09-19: 132026-09-20: 112026-09-21: 72026-09-22: 02026-09-23: 02026-09-24: 12026-09-25: 02026-09-26: 02026-09-27: 62026-09-28: 12026-09-29: 32026-09-30: 22026-10-01: 122026-10-02: 72026-10-03: 12026-10-04: 152026-10-05: 192026-10-06: 02026-10-07: 22026-10-08: 02026-10-09: 02026-10-10: 02026-10-11: 02026-10-12: 02026-10-13: 02026-10-14: 02026-10-15: 02026-10-16: 02026-10-17: 02026-10-18: 02026-10-19: 02026-10-20: 02026-10-21: 02026-10-22: 02026-10-23: 02026-10-24: 02026-10-25: 02026-10-26: 72026-10-27: 1

By commit type

feat
332
docs
315
fix
310
refactor
25
test
16
chore
10

Timeline: product, design and thesis

  1. Design

    bolt, a Streamlit app

    Turned an epic into Taiga work with Claude, keeping approved requirements in local Markdown. One Python process, four phase views.

  2. Design

    Reflex rewrite

    Renamed Apex on 7 May, then moved to Reflex for a home dashboard and tabbed phase navigation.

  3. Design

    FastAPI + Next.js split

    The Reflex monolith was replaced by a FastAPI backend and a Next.js 14 frontend (React Query, Zustand, Tailwind), deployed as two Azure Container Apps.

  4. App

    Governance analytics dashboard

    Bolt Cycle Time, Context Traceability Rate and AI Defect Escape Rate, the three metrics Chapter 6 later defines.

  5. App

    Cross-check with a second model

    A second model reviews the first model’s output.

  6. App

    Figma integration

    Frame-to-story linking, with design changes flagged into Phase 6.

  7. App

    Bring your own API key

    OpenAI, Google and Anthropic keys per project.

  8. Design

    “The Spec Ledger” design system

    PRODUCT.md and DESIGN.md written: a dense, flat interface with one violet accent and mono type for every identifier, then a full UI polish pass against it.

  9. App

    Outfolio chosen as the demonstration project

    Same day: per-task Bolt lifecycle tracking.

  10. App

    Full repository audit

    Every Critical to Low finding closed within 24 hours.

  11. Thesis

    Dissertation scaffolded

    IST template, all ten chapters as \todo stubs.

  12. App

    Plane integration merged

    A second PM adapter at Taiga parity, prompted by a partner organisation’s tool migration.

  13. Thesis

    Chapter 6 cut from 28 to 18 pages

    The framework chapter’s first real cut.

  14. Thesis

    Demonstration criteria pre-registered

    Written down before any fieldwork, to block post-hoc selection.

  15. Found by writing

    First evaluation session surfaces two bugs

    A GitHub context-pack token ceiling, and stale context still trusted at “High Confidence”.

  16. Thesis

    Evaluation data complete

    13 participants against a target of 12; none withdrew.

  17. Design

    Diagrams redrawn for the thesis

    The June architecture and user-flow diagrams were split and redrawn as the dissertation figures, and the six-phase lifecycle diagram became Figure 6.1.

  18. Found by writing

    Fix-Bolt data-loss bug

    Bug reports were overwritten instead of appended, caught while writing the chapter that describes Fix-Bolts.

  19. Thesis

    IST compliance audit

    71 of 80 pages of main text, 99 of 100 in total.

  20. Found by writing

    Bolt Cycle Time missing from the export

    The dashboard computed it; the Markdown and CSV exports never included it.

  21. Thesis

    Submitted

    Dissertation (99 pages) and extended abstract (8 pages), on the deadline.

  22. Thesis

    Defended, 17/20

    Public defence before the examination committee.

  23. Thesis

    Final post-defence version

    Role wording made consistent, committee printed on the cover.

Diagrams, then and now

Framework big-picture diagram: Strategic Alignment followed by the six phases, each with its inputs, outputs and supporting literature.
The framework’s big picture, 20 Jul 2026: phases, inputs, outputs and literature grounding

Apex & Thesis Ledger

The original dashboard this section draws on: every timeline entry, chapter write dates, page budgets and the backlog close-out.

Open the ledger

What I learned

  1. Building the framework was the hardest test of it

    On paper, every construct looked complete. Implementing it found what the text had left unsaid: Bolt Cycle Time was first measured through the wrong proxy and only caught by checking the code against its written definition, and spec-drift detection only worked once I admitted specifications are owned per story, not per project. I now ask "can I implement this?" while reviewing the idea.

  2. A control can pass and still be wrong

    The gates did their job structurally: generation alone never satisfied a phase. But the Testing Gate accepted a suite that no longer exercised the current system, and the deployment pre-flight reported high confidence from a stale context file. The next version needs gates that check how fresh their inputs are, and a control for destructive actions inside a phase, which the gate model does not cover today.

  3. People meet the method through the tool

    Interviewees liked the framework; participants rated Apex grade D (SUS 56.73), and 9 of 13 named density, orientation or navigation as what confused them, not the AI mechanisms. A cluttered screen gets read as a hard method, so first-contact usability, error legibility and visual simplicity belong in the framework’s requirements from the start.

  4. Measure the outcome you claim, or say you did not

    The demonstration recorded 19 Fix-Bolts across 14 stories; the AI Defect Escape proxy saw one. Every instrument I used measured perception, none measured delivered quality, and the only full lifecycle run was me wearing every hat. The thesis says so plainly, and the next steps follow from it: direct production telemetry, a token and compute cost metric per Bolt with a hat that owns it, and an evaluation with independent teams on more than one project-management tool.

Cite this work

@mastersthesis{taborda2026apex,
  author = {Tom{\'a}s dos Santos Taborda},
  title  = {Governed Human-AI Collaboration Across the Software Development Lifecycle: A Process Framework and Its Reference Implementation},
  school = {Instituto Superior T{\'e}cnico, Universidade de Lisboa},
  year   = {2026},
  month  = oct,
  type   = {MSc dissertation},
  url    = {https://tomastaborda.com/work/apex}
}
Write to me about the thesis