Skills

To take one language model and one person to a project that builds itself.

To take any idea, software or physical, to a foundation it can grow on without later regret.

To make a consequential choice, such as a vendor, platform, part, provider, library or where a resource comes from, against criteria taken from the project's goal.

To turn any requested change, including a vague one like "optimise it", "make it scalable" or "add AI", into one that traces to the project's goal, is verified before and after, is built through every layer it touches, and leaves nothing detached.

To take a project in any state, software or physical, to production quality.

To take a product that meets its bar to the people it is for, and hear back.

To keep a project working and getting better, at every milestone and continuously after launch.

To bring a live product back for the people it failed, then make the failure unable to recur.

To design what people and agents see, do and hear when they use a product, on a screen, a command line, an API, a voice or a device, as one design with the architecture.

To diagnose and repair the setup script so agent tasks stop failing before any code is written.

To bring a project's dependencies, runtime and build tools up to date in small steps that each prove they changed what they say, so staying current never becomes a rewrite.

To replace a repeated manual sequence with a script whose main job is being able to tell you whether the work actually happened, because an automation that reports success while blind is worse than doing it by hand.

To fix a reported bug in an order that proves the fix worked, by making the test fail for the reported reason before any code changes.

To make a test suite runnable in an agent's sandbox by removing its dependence on services it cannot start.

To describe how the system actually works, by deriving it from what runs and what imports what rather than from the folder names.

To turn an underspecified bug report into a reproducible, testable task before any fix is attempted.

To add a language to a project's documentation together with the machinery that says when a translation has gone stale, because a translation nobody can tell is out of date is worse than no translation.

To find what a migration does at production row counts, on the production engine, and on the way back down, none of which a dev database can show you.

To review a pull request an agent wrote, against the failure modes agents actually have.

To find the claims in the docs that were true when written and are not true now, by executing each one rather than reading it.

To find the tests that cannot fail, whether an agent wrote them from the implementation or they came with a fix, by breaking the behaviour or putting the defect back and watching each test go red for the stated reason.

To find the CI steps that pass because they are not running what they claim, and make each one able to fail again.

To find the failure handling that has never once executed, by causing each failure on purpose and watching what the code actually does.

To keep a private or proprietary project's code, data, designs and plans inside the places the owner chose, whether it is built fully offline with local agents and models or has to use the internet.

To review a change an agent wrote for the security defects agents specifically introduce.

To make an agent's commands to hardware, devices, machines and real-world services safe to issue and provable afterwards, because a command that was accepted is not a valve that closed.