Run · Chapter 01
Digital businesses
Fully software-native: the fastest path to autonomy.
Software makes it possible to move quickly from an idea to a working change. That speed makes the earlier decision more important: what should change, for whom, and how will anyone know it helped? An easy implementation can still solve the wrong problem.
Begin with a recent request and the evidence behind it. Put it through triage before turning it into a build task. Write a short specification naming the user’s outcome, the acceptance cases and the person who can accept the result. Include design quality: work can pass a technical check while remaining difficult to use.
Keep judgment visible through delivery
Carry the agreed purpose from specification to patch, tests and preview. Use small changes that can be inspected independently. Agentic engineering patterns documented by Simon Willison and review workflows such as Jesse Vincent’s Superpowers provide practical methods to examine; neither removes the need to judge the resulting work.
Test the behavior the user depends on, including a meaningful failure case. Review the preview against the specification and inspect which services, accounts and data the change affects. Keep credentials outside source control and identify how to restore the previous version.
Verify the released behavior
A successful build establishes that the software can be built. A preview shows the proposed experience. Publication still needs the agreed release decision, and a live check must establish that the intended version reached the intended destination.
Finish one change with its specification, review evidence, release record and rollback path. Then ask whether it improved the user’s outcome. That closes the delivery loop and gives the next request a better starting point.
Tools and setup
Practitioners: Jesse Vincent's Superpowers packages an agent development methodology; Matt Pocock's skills provide engineering interviews and task workflows. Simon Willison's Agentic Engineering Patterns documents test and review practices. Adopt a fitting method; stacking every harness increases coordination cost.
- Use a private test repository or isolated branch. Read repository instructions and establish current tests before editing. Define the problem, spec and functional/design acceptance cases; do not auto-implement every incoming request.
- Inspect a chosen skill collection and use its current client-specific installation guide. Matt's documented installer is
npx skills@latest add mattpocock/skills; select the needed skills, includingsetup-matt-pocock-skills, then invoke that setup skill to establish tracker, labels and document destinations. For Claude Code, Superpowers documents/plugin install superpowers@claude-plugins-officialinside the interactive client. Verify discovery in a fresh session and test on a disposable task. Choose one fitting end-to-end method; do not layer conflicting harnesses. - Follow GitHub Actions' quickstart: add a relevant workflow under
.github/workflows, run the project's existing checks on pull requests and inspect the job result. Keep deployment credentials separate and environment release permissions bounded. - Produce a preview, review accessibility and design references, and rehearse rollback appropriate to the change. Obtain the agreed release approval before deploying to users.
Setup paths checked against linked documentation on 15 November 2026. Verify current account support during setup; reader integrations have not been tested here.
Work through this with your agent
Paste the request into your assistant. It will interview you and help produce the working artifact.
Interview me to build one small internal tool or customer-requested change. Ask at most three questions per turn and wait. Clarify the real problem, users, expected behavior, acceptance cases, data risks and release owner. Inspect existing code and repository instructions; reuse its architecture. Turn requests into triaged evidence before deciding to implement. Draft a spec, implement the smallest coherent change, run relevant tests and review against explicit functional and design criteria. Parallel work is optional and justified only by independent tasks and clear ownership. Review factual claims, accessibility and project design conventions. Save a change summary, test evidence and deployment/rollback procedure. Prepare a reviewable patch or draft PR where authorized. Require agreed approval before live release. Never turn every request into an automatic implementation or use a reviewer persona as proof of quality. Report exactly what was built, exercised and left unverified.
Use these documented setup paths as references; check current account support before acting:
https://github.com/obra/superpowers
https://github.com/mattpocock/skills
https://simonwillison.net/guides/agentic-engineering-patterns/
https://docs.github.com/en/actions/get-started/quickstart