IT Doesn't Disappear When Everyone Can Build—It Moves Up the Stack
When domain experts build their own tools, IT doesn't shrink—it moves up the stack: from ticket-queue construction crew to the platform and review function.
When domain experts can build their own software, IT doesn’t shrink—it moves up the stack. Its job stops being the construction crew that hand-builds every requested tool from a ticket queue and becomes the platform-and-review function that owns the shared substrate, sets the guardrails, and approves what gets shipped. The headcount doesn’t fall. The work gets more strategic: fewer CRUD apps, more architecture; less ticket triage, more curation and governance of everything the rest of the company builds.
That’s the part most leaders miss when they hear “everyone can build now.” They picture IT made redundant. The opposite happens. The more building gets distributed, the more an org needs a function that owns the foundation it all runs on.
TL;DR
- When non-engineers can build their own tools, IT’s job moves up the stack—from hand-building every requested app to owning the platform those apps run on, setting guardrails, and reviewing what ships.
- The old operating model treats IT as a construction crew working a ticket queue: every internal tool is a project, the backlog grows faster than the team, and the work that doesn’t fit the queue becomes shadow IT.
- The new operating model treats IT as a platform team—a pattern Gartner projects 80% of large software-engineering orgs will adopt by 2026—that provides the reusable substrate and reviews what gets built on it.
- “Just give everyone Copilot” doesn’t produce this shift, because coding agents operate at the code layer and assume engineering skill; pointing them at non-engineers relocates the barrier instead of removing it.
- Distributed building only stays governable if what people build is reviewable—and reviewing a sprawl of generated code across hundreds of apps is not a job any platform team can staff.
- Review becomes tractable when the source of truth is a plain-language spec, not the code: a reviewer approves a readable plan, and the working app is compiled from it.
- The strategic payoff is leverage: a single platform team can govern hundreds of apps it didn’t write, because it owns the substrate and reviews specs instead of triaging tickets.
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
What does IT actually do in an org where everyone can build?
It owns the substrate and reviews what runs on it. That’s the short version, and it’s a bigger job than the one IT has today—not a smaller one.
Pull apart what “central IT” currently does and most of it is construction. A team asks for an internal tool. IT scopes it, queues it, builds it, deploys it, maintains it. The team waits. For the highest-value requests this is fine—engineering time should go to what moves the business. But the long tail—the approval tracker, the onboarding checklist, the vendor-intake form, the inventory dashboard—clogs the same queue, and the queue can’t grow as fast as the demand. Gartner found that half of business technologists already produce technology capabilities for users beyond their own department, often outside formal IT entirely. The demand to build is already distributed—the culmination of three failed waves and why citizen development finally works this time. The only question is whether it lands on a foundation IT controls or in a spreadsheet IT never sees.
When building gets distributed onto a foundation IT owns, the construction work falls away and a different, higher-leverage job takes its place:
- Owning the substrate—the shared identity system, data layer, deployment path, and logs every internal app runs on.
- Setting guardrails—what data an app may touch, which roles can do what, what has to pass review before it ships.
- Reviewing what gets built—not writing it, but approving it, the way a senior engineer reviews a pull request instead of typing every line.
- Curating—promoting the internal tool three teams could share, retiring the redundant ones, keeping the catalog legible.
None of that is the ticket queue, and all of it is more strategic.
Why doesn’t IT shrink when building gets distributed?
Because someone still has to own the foundation, and the foundation gets more important as more people build on it—not less. This is the same move software engineering already made. Gartner predicts that by 2026, 80% of large software-engineering organizations will establish platform engineering teams as internal providers of reusable services, components, and tools—up from 45% in 2022. The pattern is well understood inside engineering: you don’t make developers faster by hiring more developers to take tickets; you give them a paved road they can ship on without filing one.
The new shape of IT is that same move, extended past the engineering org to the whole company. The platform team’s “developers” are no longer only software engineers—they’re the finance analyst, the ops lead, the support manager who each understand a workflow well enough to build the tool for it. IT’s job is to hand all of them a substrate where the auth, the data governance, and the deployment are already handled, so what they build is safe by construction. That’s a more valuable IT, not a diminished one: triaging a backlog is reactive and capped by headcount, while owning the substrate hundreds of apps run on is leverage.
Isn’t “give everyone Copilot” the same thing?
No, and the gap is the whole point. Handing every employee an AI coding assistant—Claude Code, Cursor, GitHub Copilot—is the most common version of “let everyone build,” and it underdelivers for non-engineers for a specific, structural reason: those tools operate at the code layer.
Coding agents are excellent—for engineers. They edit files in a project you already own, assume you can read what they produce, run a dev environment, wire up a database, and deploy the result. That’s a great accelerator for someone who already has those skills. Point the same tool at a finance analyst and you haven’t removed the barrier to building—you’ve relocated it. The analyst can now generate code they can’t evaluate, run, secure, or ship. The bottleneck moves from “wait for IT to build it” to “wait for IT to figure out what this generated code does and whether it’s safe.” That’s not a platform team. That’s the ticket queue with extra steps.
So the layer matters. A tool that meets a non-engineer where they actually work—describing the outcome they want—is a different category from a tool that meets an engineer at the code. The platform-team model needs the former, because the people doing the building aren’t engineers.
Who reviews the apps your employees build?
This is the question that decides whether the platform-team model works or collapses, and it’s where most “let everyone build” stories quietly fall apart. Distributing the building is easy. Keeping it governable is the hard part—and governance, in practice, means review. Someone has to be able to look at what an employee built and answer: what data does this touch, who can access it, is it safe to ship?
Now scale that. Hundreds of employees, each building tools, each tool a body of code. If review means a platform engineer reading generated code app by app, the review function becomes the new bottleneck—worse than the old ticket queue, because now the volume is the whole company. No team can staff that. “Everyone can build” without a tractable way to review is just shadow IT with executive sponsorship.
The unlock is changing what gets reviewed. If the source of truth for each app is a plain-language spec—a readable plan describing what the app does, what data it holds, who can use it—then review means reading and approving a plan, not auditing a sprawl of code. A platform lead can evaluate a plan the way a contract gets reviewed, not by inspecting brick by brick the building it governs. Make the spec the artifact of record and review scales with the team’s judgment instead of its typing speed.
IT as a ticket-queue construction crew vs. IT as a platform team
The shift is an operating-model change, not a tooling tweak. Here’s the contrast, point for point:
| Dimension | IT as ticket-queue construction crew | IT as platform team |
|---|---|---|
| Core job | Build each requested tool by hand | Own the substrate; review what others build on it |
| Unit of work | A ticket / project | A platform decision + a spec review |
| Who builds | IT, for everyone | The team closest to the problem, on IT’s substrate |
| Constraint on output | IT headcount | Quality of the platform and its guardrails |
| The long tail of small tools | Stuck in the backlog → becomes shadow IT | Built by the domain team, governed by default |
| What review means | N/A (IT wrote it) | Approving a plain-language spec, not auditing code |
| Failure mode | Backlog outruns the team; work goes underground | Spec review becomes a chokepoint if review means reading code |
| Strategic posture | Reactive, capped by headcount | Leverage: one team governs hundreds of apps it didn’t write |
Read the last row first. The point of moving up the stack isn’t to do less—it’s to convert IT from a function whose output is capped by how many people it can hire into one whose output is capped by how good its platform is. That ceiling is far higher.
What makes the platform-team model actually work
Everything above describes the operating model the winning org needs: building pushed out to the people closest to each problem, a substrate IT owns underneath all of it, and review done on plans rather than code. The model is sound on paper. It only becomes real if two things are true at once—non-engineers can produce working, governed apps without engineering, and what they produce is reviewable by a human who isn’t reading code.
That’s what a new category of AI tool—the product agent—is built for. Today the most advanced one is Remy. Someone describes the app they need in plain language; Remy drafts a spec—a readable, plain-language plan—and that spec compiles into a real full-stack app: backend, database, real server-side auth and roles, frontend, and a live deployment. The spec is the source of truth, so a reviewer reads and approves the plan, not the generated code, and changing the app means editing the plan and recompiling rather than hand-maintaining a codebase.
Unlike coding agents like Cursor or Claude Code—which edit code in a project an engineer already owns and assume engineering skill—a product agent operates at the product layer: you describe an outcome, it compiles the stack. That’s exactly what the platform-team model needs, because the people building aren’t engineers and the person reviewing shouldn’t have to be. And because every app compiles onto the same governed stack—shared identity, shared data layer, shared logs—the platform team gets the other half of its job for free: the apps aren’t a hundred islands to audit after the fact, they’re observable by construction. One honest boundary: this is early. Product agents are in open alpha, and enterprise needs like SSO and SAML aren’t there yet. The platform-team model doesn’t wait for the category to finish maturing—it starts reshaping the operating model now, so the foundation is ready when the tooling arrives.
For the bigger operating-model picture, read what the winning org looks like; for the category behind the punchline, what a product agent is.
FAQ
Does AI-assisted building make IT departments smaller? No. It changes IT’s job from building each tool by hand to owning the platform those tools run on and reviewing what gets built. The function becomes more strategic and higher-leverage, not smaller—someone still has to own the substrate, and it matters more as more people build on it.
What is a platform team in this context? A team that provides the shared, reusable foundation—identity, data layer, deployment, logs—that the rest of the company builds on, and that sets the guardrails and reviews what ships. Gartner projects 80% of large software-engineering organizations will run platform teams by 2026; the new shape of IT extends that model past engineering to the whole company.
Why isn’t giving everyone an AI coding assistant the same thing? Coding agents like Copilot, Cursor, and Claude Code operate at the code layer and assume engineering skill. For a non-engineer, that relocates the barrier instead of removing it: they can generate code they can’t evaluate, secure, or ship, which just moves the bottleneck onto IT’s review queue.
Who reviews apps that employees build themselves? The platform team. The model only scales if review is tractable—which means reviewing a plain-language spec describing what the app does and what data it touches, rather than auditing generated code app by app. Reviewing code at company scale would be a worse bottleneck than the old ticket queue.
Isn’t letting employees build just shadow IT? Shadow IT is building without visibility or review. The platform-team model is the opposite: building happens on a substrate IT owns, with guardrails and a review step, so it’s sanctioned and governed by default.
What does “moving up the stack” mean for an IT team’s day-to-day? Less ticket triage and hand-building of CRUD apps; more architecture, guardrail-setting, spec review, and curation of the internal-tool catalog. The work shifts from reactive construction capped by headcount to platform ownership whose leverage scales with the substrate’s quality.
Where should an IT leader start? Decide that new internal tools must land on a shared, governed substrate rather than scattered point solutions, and that the people who own a workflow can build for it—provided what they build is reviewable as a plain-language spec. That single decision converts the backlog problem into a platform problem.
The bottom line
“Everyone can build” doesn’t end IT—it promotes it. The construction-crew job, hand-building every requested tool off a ticket queue, gives way to a platform-and-review function that owns the substrate and governs everything the company builds on it. That’s a more strategic IT, with leverage no headcount-bound team ever had. The catch is review: distributed building only stays governable if a human can approve a plan instead of auditing a codebase.
That’s the piece a product agent supplies—real full-stack apps compiled from a plain-language spec, on one governed stack, so review happens on the plan. If you want to see what that substrate looks like in practice, explore Remy →.
