Skip to main content

Accountability: You Own What You Deliver

Basic

Applies to: every contracting developer who delivers code, configuration, or documents to a customer · Time to learn: 30 min reading + 15 min to adapt the checklist to your current engagement

As a contractor, the customer sees one accountable person: you. They do not see which lines you typed, which an agent drafted, and which came from a library. They see a delivery that works or does not, a date that holds or does not. This page sets a very high bar for ownership and shows the habits that make it achievable.

TL;DR
  • You are responsible for everything you deliver, whether you wrote it by hand or with an AI agent. "The AI wrote it" is never an answer to a customer.
  • Ownership means you can explain every line you ship, you ran it, and you tested it.
  • Review every diff, verify every claim, API, and licence, and keep secrets and customer data out of tools the contract does not approve.
  • Estimate with ranges and assumptions, track against them, and raise risk the moment you see it, never on the deadline day.
  • When something breaks or you missed something, own it fast: tell the customer, fix forward, and send a short report (what happened, impact, root cause, fix, prevention).
  • Internally we run blameless reviews to learn. Toward the customer, you speak as the owner.

Why it matters in the AI age​

Coding agents make it cheap to produce a large diff. They do not make it cheap to be right. Anthropic's own Claude Code guidance names the failure directly: a plausible-looking implementation that misses edge cases, with the rule "If you can't verify it, don't ship it" (best practices). OWASP lists misinformation (confident but wrong output) and supply chain risk among the top risks for LLM applications (OWASP Top 10 for LLM Applications). Speed from an agent is real, and the accountability for the result stays with the human who ships it.

The customer's contract is with your company and your name is on the pull request. Treat generated output exactly like code from a new colleague you have never met: useful, unproven, and yours to answer for once merged.


What ownership means​

You own a delivery when all three statements are true:

  1. You can explain it. For every line, file, and dependency in the change, you can say what it does and why it is there, without re-asking the agent.
  2. You ran it. You executed the code path yourself (or watched the agent's command output and read it), not only saw it compile.
  3. You tested it. There is evidence: automated tests, a reproducible manual check, or a screenshot, attached to the change.

Ownership also covers omissions. A requirement you did not read, an edge case you did not test, and a date you did not flag are all yours. "I assumed" is a fine start of a sentence only when it continues with "and I told you on Tuesday".

SituationWeak answerOwner's answer
Bug in generated code"The assistant produced that.""I shipped a bug in the retry logic. Fix is in review, here is the test that would have caught it."
Missing requirement"It was not obvious from the ticket.""I did not confirm that requirement. I will confirm it today and send you the impact on the plan."
Late delivery"Things took longer than expected.""I will miss Friday. New date is the 14th, cause is the unstable test environment, options below."
Broken upstream library"That is a third-party issue.""A dependency I chose has a defect. I pinned the previous version and opened an upstream issue."

AI-assisted delivery rules​

Using an agent is normal and encouraged (see AI-Native Engineering). These rules keep it safe for the customer.

Review and verify​

  • Read every diff before it leaves your machine. Large agent diffs are split into reviewable steps; if you cannot review it, it is too big to ship in one piece.
  • Give the agent a check it can run (tests, build, linter) and read the output yourself. Ask for evidence, not assertions (best practices).
  • Verify claims and APIs against official documentation: function names, parameters, version numbers, config keys, and "this library supports X". Models can state wrong facts fluently.
  • Use a second look. A fresh-context review (a separate session or subagent) catches things the writing session is biased against seeing (best practices). It supports your review and never replaces it.
  • Enforce what must always happen with hooks, pre-commit, and CI rather than relying on memory: see Hooks and Quality Gates.

Data and tools​

  • Use only tools the contract and customer policy allow. If the contract is silent, ask in writing before you paste anything from the customer's environment into an AI tool.
  • Keep secrets and customer data out of prompts, logs, and memory files unless the tool is explicitly approved for that data class. OWASP lists sensitive information disclosure as a top LLM risk (OWASP).
  • Limit agent permissions. Agents that can run commands and call services carry the risk of excessive agency (also an OWASP LLM top-10 item). Scope them to the task and the sandbox.

Disclosure, provenance, and licence​

  • Disclose AI use where the contract, the statement of work, or the customer's policy requires it, and be ready to describe how you used it. When the rule is unclear, ask. Asking early costs a message; discovering the rule late costs trust. See Contracts, Scope, and Boundaries.
  • Check provenance and licence of anything generated or pulled in. Prefer well-known licences compatible with the customer's use, record third-party code in the dependency manifest or notices file, and flag generated blocks that look copied from a recognisable project.
  • Keep a short delivery log (what was generated, what was changed by hand, what was verified). It makes questions from the customer easy to answer.
Regulation and customer policy

AI-use obligations vary by country, sector, and customer. If your customer or your own team operates under rules that cover AI use (for example AI literacy or transparency duties), follow the version that applies to your engagement and raise open questions with your lead early. This page does not replace legal advice.


Accountability for others' work you integrate​

Choosing to integrate something makes its behaviour part of your delivery.

  • Dependencies and open source: you picked them, so you vet them: maintenance status, known advisories, licence, and pinned versions. OWASP names supply chain as a top LLM application risk and the same discipline applies to all dependencies (OWASP).
  • Agent output: same as your own code. Reviewed, tested, explained.
  • Teammates' and customer's code you build on: if you find a defect that affects your delivery, report it with evidence and a proposed handling, and do not quietly work around it.
  • Snippets from the web or chat: treat as untrusted input until you have understood and tested them.

Definition of done you hold yourself to​

Agree the customer's acceptance criteria first (see Customer Communication). On top of that, apply this personal bar. Shared engineering standards live in How We Build; do not duplicate them here.

  • Tests: new behaviour and the bug you fixed have automated tests that pass in CI, and you saw them fail first when practical.
  • Docs: README or runbook explains how to build, run, configure, and operate the change.
  • Security checks: no secrets in the diff or history, dependency scan clean or findings explained, input handling and permissions reviewed.
  • Licence and provenance: third-party and generated code accounted for.
  • Handover: the customer team can run, change, and support what you built without you: access, credentials rotation, known limits, open issues.
  • Acceptance evidence: you can show each acceptance criterion met, with output or a demo.

Estimates and deadlines​

Estimate honestly​

  • Give a range (for example 6 to 10 days) plus the assumptions behind it (environment access by day 2, one review round, stable API).
  • Separate known work from discovery; label discovery as such.
  • State what is not included.
  • Re-estimate when an assumption breaks, and tell the customer which one.

Track against the estimate​

  • Compare progress to the plan at least weekly, and daily near a date.
  • Keep a visible risk list with owner and trigger date.
  • A slip you noticed on Monday and told the customer on Monday is a schedule issue. The same slip told on Friday is a trust issue.

When you see a deadline risk​

The message to send has five parts:

  1. Early notice: "I am at risk on the 14th delivery."
  2. New date: a specific date or a narrow range, and when you will confirm it.
  3. Cause: one factual sentence, with no blame and no excuse.
  4. Recovery plan: what you are doing and what you need from the customer.
  5. Options to cut scope: what could ship on time if priorities change, and the cost of each option.

If an option changes scope, price, or timeline, it goes through the change process in Contracts, Scope, and Boundaries.


When something breaks or you missed something​

  1. Stabilise and tell the customer fast. Say what you know, what you do not yet know, and when the next update comes.
  2. Fix forward. Restore service or correct the defect first; deep analysis follows.
  3. Do not hide or minimise. State the impact plainly, including the part that is uncomfortable.
  4. Send a short report within the agreed time (a day or two for most issues).
  5. Close the loop. Deliver the prevention items, and tell the customer when they are done.

Short incident or miss report​

report-template.md
## Summary
One or two sentences: what happened and the current state.

## Impact
Who or what was affected, for how long, and how we know.

## Timeline
Key times: introduced, detected, mitigated, resolved.

## Root cause
The contributing causes in enough depth to be useful, including my part in them.

## Fix
What was changed, and how it was verified.

## Prevention
Concrete actions, each with an owner and a date.

The structure follows what the Google SRE book lists for a good postmortem: the incident and its effect, the mitigation steps, root causes examined in depth, and follow-up actions that reduce recurrence (SRE book: Postmortem Culture). Write the root cause in the first person ("I merged without running the integration suite") and keep names of colleagues out of it.

Warranty and defect handling​

Follow the contract: what counts as a defect, the warranty period, response and fix times, and what is billed separately. Acknowledge a defect report within the agreed window, reproduce it, fix it, and add a regression test. If you think a report is a change request rather than a defect, say so politely with the contract clause, and do not argue it in the middle of an incident. Details of scope boundaries are in Contracts, Scope, and Boundaries.


Blameless internally, owned toward the customer​

These are two different tools that work together.

Internal reviewToward the customer
GoalImprove the system and the processRestore trust and give certainty
Voice"The pipeline allowed an unreviewed merge""I shipped this, I am fixing it, here is the date"
NamesNo individual blamed; assume good faithOne accountable owner: you (and your lead)
OutputProcess and tooling changesReport, fix, prevention, follow-up

The SRE book describes the blameless postmortem as focusing on contributing causes without indicting individuals, on the assumption that everyone acted in good faith with the information they had (SRE book). Use that culture inside the team so people report problems early. Toward the customer, never push the cause onto a colleague, a tool, or a model.


Pitfalls to design around​

  • Review the diff before the push. Block time for reading agent output; a green build is a minimum, not a review.
  • Name your assumptions in the estimate. A range with assumptions is defensible; a single number is a promise you cannot keep.
  • Raise the flag at first sight. Put a "risk review" slot in your weekly rhythm so doubts become messages early.
  • Check the contract before you paste. One question about approved tools saves a data-handling incident.
  • Lead with the fix and the date. Customers first want certainty, then the story.
  • Report your own part. A report that names the system and your own role reads as ownership.
  • Pin and record what you integrate. Versions, licences, and origin in the repo make audits easy.
  • Test the unhappy paths. Agents tend to produce the happy path; ask for failure cases and run them.
  • Hand over, then confirm. Ask the customer to run the handover steps once while you are still on the engagement.

Pre-delivery checklist​

  • I read every diff and can explain every file in it.
  • I ran the change and tests myself; evidence is attached.
  • APIs, versions, and claims were checked against official docs.
  • No secrets or customer data were sent to a tool the contract does not approve.
  • AI use is disclosed where the contract or customer policy asks for it.
  • Licences and provenance of new dependencies and generated code are recorded.
  • Security checks ran (secrets scan, dependency scan, permissions review).
  • Docs, runbook, and handover steps are complete.
  • Each acceptance criterion has demonstrable evidence.
  • The next date is still realistic; if not, I have already told the customer.
  • Known limits and open issues are written down and shared.

Sources​