Source: raw/Cheap_software_made_your_PM_job_harder_not_easier._Here_s_the_new_job..md (Nate B Jones YouTube, youtube.com/watch?v=b6J387xJvHg). Refreshed 2026-09-29 with raw/Runable_Raised_21_Million_On_Agents_That_Finish._Nobody_Told_Yours_What_Done_Means..md (Nate B Jones, “Runable Raised $21 Million On Agents That Finish. Nobody Told Yours What Done Means.”, youtube.com/watch?v=qYe1GsMRElw).

Nate B Jones lays out a concrete, named framework for the problem AI abundance creates inside companies: when generating software is nearly free, the bottleneck stops being “should we build this?” and becomes “how do we classify the software that already exists?” His answer — the “production class ladder” plus a prototype-commons posture and promotion/demotion governance — is a transferable decision framework for the new PM/ops job. It’s a governance-of-AI-output companion to the runtime/policy tooling in Microsoft’s Agent Governance Toolkit: that toolkit governs what agents do; this framework governs what people build with AI.

Key Takeaways

  • The PM job inverted. AI makes generation cheap, so the bottleneck moves from “should we build this?” to classifying software that already exists into market value / useful internal tooling / delete. PMs shift from “rationing scarce engineering” to “classifying software abundance.” Jones: “There is not much room left for the non-technical PM.”
  • The decision rule: stop asking only “can my team build faster?” Ask “what class of software is this?” — then “should this exist, who’s it for, what standard must it meet, what are we willing to rely on?”
  • A ladder needs a down-staircase. “A ladder that only moves upward becomes a junk drawer.” The new tech debt is dead internal software you keep paying support cost on — “the company will pay support cost on dead software faster than it can name it.”
  • Governance is permission-to-build, not a build-ban — the Microsoft Power Platform model: let employees build while protecting the company via inventory, telemetry, permission review, environment controls, and data policy.
  • Faster creation multiplies leak surface — which is why “what data does it touch / who owns it” becomes a product question, backed by the GitGuardian secret-sprawl numbers below.

The production class ladder (4 rungs)

Each rung carries explicit requirements — the ladder is the classification scheme a PM applies to any AI-built tool:

  1. Personal tool — one user, scrappy. Keep it away from sensitive data.
  2. Team beta — a small group depends on it. Needs an owner + backup owner, a short description, a list of systems it touches, and a failure plan.
  3. Supported internal product — the company depends on it. Needs product ownership, platform partnership, access management, monitoring, docs, auditability, and a change process.
  4. Customer-facing product/feature — usual product standards plus AI-specific evals and governance.

Promotion and demotion. PMs now decide what gets promoted out of the prototype commons and what gets intentionally demoted or left as personal software. The down-staircase is the part most orgs skip — and skipping it is what turns the ladder into a junk drawer of unsupported tools.

The prototype commons + “open discovery”

  • The prototype commons is the informal space where tools appear before classification.
  • The recommended posture is open discovery, not gatekeeping: “Show us what you made. What problem does it solve? Who uses it? What data does it touch? What did you learn?” — rather than “the PM is the only prototyper.” Jones: “everybody’s job is to prototype.”

The data spine

  • Microsoft Power Platform internal scale (the proof case): >1M Power Platform assets built inside Microsoft — >18,000 agent environments, 170,000 Power Apps, 50,000 Power Automate flows, 1,200 chatbots — governed by inventory, telemetry, permission review, environment controls, and data policy. Framed as “let employees build while protecting the company,” not a build-ban.
  • GitGuardian 2026 State of Secret Sprawl: AI-service secrets exposed on public GitHub hit 1.2M in 2025, up 81% YoY — used to argue that faster creation multiplies the leak surface, making “what data does it touch / what does it write to / who owns it” a product question, not just an engineering one. ^[inferred — Jones predicts another 80-100% rise this year; that’s his bet, not data]

A legibility test for agent-written code (2026-09-29)

In a later video, Jones gives a test for whether agent-written code is fit to keep. It is a practical bar for promoting a tool to rung 3 or 4. ^[inferred — the link to the ladder is this wiki’s]

  • The 20-minute test. Can “your second or third best engineer,” someone “not the one person who understands every corner of the system,” open a random file and “explain what it does and why it’s there after 20 minutes or less”? If they can’t trace the logic, find the tests and see how the file connects to the rest, the agent “may have completed the ticket while making the code base much harder to operate.”
  • Checks to add on top. Cap how large files and functions may grow; Jones says agents need that constraint even though human engineers resent it. Comments should “explain your thoughtful engineered trade-off decisions rather than just narrating obvious syntax.” Tests should protect behaviour, not be “rewritten to bless the answer.”
  • Cyclomatic complexity. Count the independent decision paths through a function. He has seen it fall “from 91 to like 12 after an audit.” That is one anecdote, not a benchmark.
  • For go-to-market agents, use the business’s own numbers. Don’t grade on “leads scraped or messages sent.” Grade on “speed to lead, time to a booked meeting, conversion to a real opportunity, deal size, customer acquisition cost, revenue in the door, pipeline.”

Try It

  1. Adopt the 4-rung ladder as your classification scheme. For every AI-built tool in your org, assign a rung and attach that rung’s requirements (owner, systems-touched list, failure plan, monitoring, evals as applicable).
  2. Build the down-staircase first. Schedule a recurring demotion review — what gets left as personal software, what gets deleted — before your prototype commons becomes a junk drawer of unsupported tools.
  3. Run open-discovery intake, not gatekeeping: the four questions (problem / users / data touched / lessons) are the cheapest governance you can apply at the prototype-commons stage.
  4. Make the 20-minute legibility test a promotion gate. Before an agent-built tool moves up a rung, have a mid-level engineer explain a random file from it within 20 minutes, and add a file-size limit and a cyclomatic-complexity ceiling to its CI.
  5. Pair it with runtime governance. Where a tool graduates to rung 3-4, layer in policy/identity/audit enforcement — see Microsoft Agent Governance Toolkit.

Open Questions

  • Jones’s “another 80-100% rise” in secret sprawl is a prediction, not data — track GitGuardian’s next report.
  • The legibility test and the 91-to-12 complexity drop are Jones’s opinion and anecdote; no before/after data on maintainability is given.
  • The framework is a single-creator synthesis (well-grounded in cited Microsoft/GitGuardian numbers) — no independent org has published results applying the exact 4-rung ladder yet.