NeuroScope — Building got cheap. Knowing what you built didn't.

The shift

Agents didn't just change how software gets written

They changed which part of the job is hard. Writing the code stopped being the bottleneck; everything on either side of it became one.

Capacity stopped being the constraint

You can have five times the output tomorrow. What you cannot have is five times the people qualified to judge it. Output arrives faster than anyone can read it, and the queue forms at the review, not the keyboard.

A vague ticket became expensive

A person asks. An agent assumes. Ambiguity used to cost a two-minute conversation; now it buys you a week of confidently wrong software that looks finished and passes review at a glance.

The bill arrives undifferentiated

One model invoice at the end of the month. Nothing in it says which feature cost what, so "cost-effective" stays a belief you hold rather than a number you can show anybody.

The job

The project manager's job inverts

It used to be mostly allocation and chasing. When capacity is no longer scarce, what becomes scarce is precision going in and rigour coming out.

What the job used to be

Allocation and chasing

Scarce people, abundant work. Most of the role was deciding who did what, then finding out whether they had.

Who is working on what this sprint
Why is it late, and by how much
Standing meetings to collect status
Estimating human weeks against a roadmap

Status came from people, so the job was getting it out of them.

What the job is now

Specification and verification

Abundant capacity, scarce judgment. The role is being exact about what to build, then proving what came back is it.

Writing criteria an agent cannot misread
Grading delivery against those criteria
Reading evidence instead of collecting status
Pricing a feature before committing to it

Status comes from the work itself, so the job is reading it correctly.

Specify precisely

Every work item carries criteria that can actually be tested, a surface, an owner and a budget. The spec is not paperwork — it is the contract the verdict will be graded against.

Verify ruthlessly

No completion is accepted on a claim. It is checked against the code, the scanner and a real test run, and carries a figure a named person stands behind.

Price per unit

Agent spend and elapsed time attributed to the thing delivered, so the economics of every feature are visible before and after you commit to it.

The loop

NeuroScope governs. NeuroHive executes.

The two form a cycle, not a stack. One decides what is worth building and proves it was built; the other actually builds it.

NeuroScope

Specify

Intent becomes a work item: acceptance criteria, surface, priority, budget. Precise enough that an agent cannot build the wrong thing politely.

NeuroHive

Execute

The right model, the right standing context, access to the right repo and hosts — agents do the volume under guardrails.

NeuroHive

Emit

Real work leaves a trail: commits, sessions, deployments, token spend. None of it knows which promise it was keeping.

NeuroScope

Verify

That trail is graded against the criteria from step 1. Completion %, test verdict, security and quality findings, cost.

Closes the loop

Promote

What was accepted flows back as standing context, so the next agent starts knowing the decision instead of relitigating it.

Step 5 feeds step 1 — verification output becomes execution input

That last step is why the two are worth more together than apart. A conclusion NeuroScope certifies stops being a row in a report and becomes something every future agent is told.

Going in

An agent is literal. Write accordingly.

The cheapest defect to fix is the one caused by a sentence nobody pinned down. Work items in NeuroScope are built to be handed to something that will do exactly what they say — and nothing they merely imply.

Criteria that can be tested — each one a statement that is checkable, not a paragraph of intent. If it can't be verified later, it can't be accepted later.
Surface, owner, budget — attached before dispatch, so a run that overspends is visible while it is happening rather than at invoice time.
Standards carried forward — decisions already accepted are attached automatically, so the same argument isn't had a third time in a new ticket.
The spec is the contract — the same criteria that go to the agent are the ones the verdict is graded against. There is no second, softer definition of done.

⬡ Work item #151 — ready to dispatch

PortalMulti-site job templatesowner: delivery · budget $120 · priority 2

Acceptance criteria · 7

1Create a template from an existing jobtestable · UI + API

2Apply a template across multiple sitestestable · API

3Template versioning on edittestable · API

4Permission check on cross-site applyblocked · needs the multi-site role decisiondecide

Attached standards · Role model v2 · Audit every write · No raw storage URLs

Coming out

Every Done is graded, not accepted

A board records what somebody said happened; a repository records what actually did. Delivery is the intersection, and no tool you already own can see it. NeuroScope reads both and puts one figure on each item that a person stands behind.

Completion % — written by someone who read the criteria against the code. Not a burndown, not a commit count, not a model's guess.
Quality, per item — open scanner findings intersected with the files that item touched, so "it's done but the scanner disagrees" shows on the row.
A full-criteria test verdict — from a real run against the live environment, with the evidence quoted, and only ever on items currently claiming Done.
Contradictions rendered, not smoothed — an item moved to Done with nothing behind it shows as Done · 0%, on the page, in front of everyone.

⬡ #151 — delivery evidence

CriteriaCommits 6Sessions 9 TimelineCost

✓Create a template from an existing jobportal/templates/create.tsx · 3 commits

✓Apply a template across multiple sitesapi/templates/apply.ts · 2 commits

✓Template versioning on editapi/templates/version.ts · 1 commit

✗Permission check on cross-site applyno code found

·Audit entry per template applicationnot assessed

Verdict · 62%. Four of seven criteria have code behind them. The cross-site permission check is the blocker and it is still waiting on the role-model decision.

Ask Lens

Lens is the reasoning layer inside NeuroScope — a tool-using agent, not a chatbot with your project pasted into a prompt. It holds no knowledge of your work and has to go and find out: a factual question forces a lookup before it is allowed to answer, and a partial answer arrives labeled partial rather than dressed up as a complete one.

Ask it out loud

Persistent microphone, local voice detection, speech to text, the agent, then spoken progress cues while it works — talk over it to interrupt. The audio only ever reaches your own server. Built for the ten minutes before a status meeting you haven't prepared for.

Quality & security

Nobody is reading all of that code

Human review was the backstop for quality and security. At agent volume that backstop is gone — and the scanner becomes the only thing that reads every line you ship.

Findings land on the work item, not in a dashboard nobody opens

A scanner produces a list, and a list is not accountability. NeuroScope intersects every open finding with the files each work item actually touched, so quality and security arrive on the row beside the completion figure — in front of the person deciding whether to accept it, at the moment they decide.

A vulnerability is not a code smell — security findings are separated from quality findings and counted as hard. A smell is a conversation; a vulnerability in the files you are about to accept is a stop.
Acceptance can be gated on it — an item that meets every criterion and carries an open high-severity finding is not done. The verdict says so, and the release gate honors it.
Open and resolved, both — browse what is still outstanding and what was fixed, with close dates and the commit that did it. A clean gate becomes provable rather than asserted.
Coverage measured, not assumed — test coverage is generated as part of the scan, so the number describes this build rather than the last time somebody remembered to produce one.

⬡ Quality & security — Release 2

Open 14Resolved 86 GatesCoverage

vuln Presigned URL signed against the internal hostapi/uploads/presign.ts · item #146 high

bug Unhandled rejection aborts the import silentlyportal/import/run.tsx · item #147 major

bug Date parsed without a timezoneapi/shifts/window.ts · item #142 major

smell Cognitive complexity 24, limit 15portal/templates/apply.tsx · item #151 minor

fixed Role check missing on cross-site applyclosed 2 Oct · commit 3a247c3 · ticket #592 ✓

api · gate passedportal · gate failed worker · gate passedcoverage 23.8%

Scans run whether CI remembers or not

The scan is a timer that owns itself, not a pipeline step somebody can skip to get a build green. If the measurement is optional, the measurement is decoration — and the first thing under deadline pressure to become optional is the one that says no.

Scanners forget. The record shouldn't.

Most scanners purge closed findings from their own API, so the proof you fixed something has a shelf life of weeks. NeuroScope snapshots every finding nightly, which makes those snapshots the only permanent answer to "what did we fix, and when".

One ticket per finding, never a batch

Every resolved finding gets its own issue, annotated on both sides — in the tracker and in the scanner itself. A fix traces to a commit and a date, which is the difference between a clean board and a believable one.

None of this is hygiene for its own sake. An unresolved finding is deferred cost with no due date on it — which is why it sits next to the money.

The economics

Cost per delivered story

This is the number the project manager is actually judged on, and almost nobody can produce it. A model invoice tells you what the month cost. It cannot tell you what the feature cost, which means it cannot tell you whether the next one is worth starting.

Spend attributed to the item, not the month — every agent session is tied to the work item it was dispatched for, so the invoice decomposes.
Build separated from rework — the second and third attempts at the same criterion are counted separately. Rework cost is the honest measure of how good your specs are.
Elapsed time from spec to accepted — the cycle time that matters, measured between two events a machine can see rather than two meetings.
A figure you can take to finance — "this release cost $3,180 and here is the per-feature breakdown" is a different conversation from "AI is saving us money".

⬡ Cost per delivered item — Release 2

ItemBuildReworkTotal

Shift check-in with geofenceaccepted · 6 days $33$8$41

Multi-site job templatesin flight · 11 days $44$34$78

Bulk CSV importaccepted · 4 days $19$3$22

Saved report viewsin flight · 3 days $12$0$12

Templates is 44% rework — the highest on the release. The spec went out with one criterion still undecided, and the agents have rebuilt around it twice.

Two products, one loop

NeuroHive supplies the capability.
NeuroScope governs its use.

They split along a clean seam — and either one works on its own. Together they close the circuit.

	NeuroHive	NeuroScope
Question it answers	Can the agents do the work?	Was the right work done, and what did it cost?
Primary user	Engineer, builder	Project manager, delivery lead
Owns	Context, memory, models, secrets, hosts, agent sessions	Backlog, acceptance criteria, verification, quality and security, cost per story
Mode	Execution	Governance
Metaphor	The engine room	The bridge

Where they physically touch

Shared project identity

One project, two views — the builder's and the project manager's. Neither side has to reconcile a different list.

Spec out, evidence in

NeuroScope writes the work item; NeuroHive returns the commits, sessions and deployments made against it.

Cost attribution

NeuroHive knows model spend per session; NeuroScope attributes it to the item. Neither produces cost per delivered story alone.

Accepted becomes standing

Decisions NeuroScope verifies are promoted into NeuroHive's memory, so future agents inherit them instead of rediscovering them.

Verdict as a gate

Acceptance in NeuroScope can gate the release step in NeuroHive. Nothing ships on a claim.

NeuroHive is how the work gets done.
NeuroScope is how you know it was worth doing, and that it was actually done.

Guardrails

A tool that grades your delivery had better not be able to change it

Independence isn't a posture here, it's an architecture. The thing being measured cannot be edited from the thing doing the measuring.

Read-only across the boundary

NeuroScope holds read scopes on your repositories, your scanner and your execution platform, and writes nothing back to them. The only things it writes are its own: specs, verdicts, notes, roles and its audit log.

Nobody is in by default

Single sign-on in front, and the application publishes no ports of its own. A new sign-in lands in pending and sees an awaiting-approval page until an admin promotes them. Five roles, every change audited.

Enforced in the API, not in CSS

Cost, hours and audit surfaces gate the page and the endpoint, so poking at a URL returns a 403 rather than a result. Admin impersonation can only ever drop privileges, and the log records both identities.

Agents write code faster than anyone can read it.