inixiative presents:

How worried should you be?

Not very. Any model can write code that runs. That's the floor, and the floor is crowded. Do I Still Have a Job? measures what the demos skip: the judgment to build the real thing (small, deep, complete) instead of a thin MVP that passes its own tests or a tower of machinery the problem never asked for.

How a run works

  1. We hand the agent a product brief, the kind a PM and a senior engineer would leave a kickoff with. Requirements and why they matter. Not the design, not the data shapes, not the failure handling. Working those out is, you know, the job.
  2. It builds the thing in a sealed sandbox, with the real inixiative foundations sitting right there to build on, and writes a DEVLOG.md defending its choices, including how hard it thinks the problem was. (It is usually wrong about that.)
  3. A judge that has read the real implementation front to back grades it against a weighted rubric. It traces the data flow and gives no points for code that merely looks confident.

The only variable is the human

The gap means something because the references weren't hand-built by artisans refusing to touch a model. They were written 100% with AI, with the same class of tools the agents get. The difference is that a human stayed in the loop: steering, rejecting, re-aiming. An agent's solo run next to the reference is the same machine with and without an architect driving, and the distance between them is what the driving is worth. Autonomy is the dividing line: the day a model clears these unsupervised is the day the job changes. So far it isn't close.

What we score (separately, with no single vanity number)

No answer key, and no training data

Each problem shows up only as a numbered test and a difficulty. We don't name the repo and we don't publish the rubric, so the board isn't a map to the answers. We publish the result, not the answer key.

And the references themselves are unlikely to be in the training data. They're open source, but new and niche, so the models we ran are unlikely to have trained on them. This measures whether an agent can reason its way to a near-optimal design it has never seen, not whether it can recall one. It also explains the usual failure: agents reach for the shape they were trained on (a CASL-style permission seam, a fat config object) instead of the compressed, in-engine design the reference uses. A high score here is suspicious, not impressive: there's nothing to memorize.

The substrate

The problems come from the inixiative primitives: small, deliberately minimal, and hard to reach. We're talking a few hundred lines, not thousands: full RBAC + ABAC + ReBAC in about 1k lines, that sort of thing. Most engineers haven't built one of them small and complete, and the gap between "it runs" and "it's right" is wide enough to put on a chart.