Every line of code is a liability with a maintenance schedule. Every endpoint is attack surface. Every scheduled job is a recurring charge and a recurring failure mode. Every dependency is someone else's bug in your production.
The software industry knows this and does the opposite anyway. We add. We add features, flags, services, cron jobs, wrappers and, increasingly, AI-generated code by the thousands of lines. Then we spend our best engineers optimizing and automating things that should never have existed.
The fix has a well-known name.
Walter Isaacson's biography of Elon Musk describes the five-step "algorithm" Musk repeats at Tesla and SpaceX production meetings "to an annoying degree" (excerpt):
The order is the insight. Most engineering organizations run steps 3 to 5 enthusiastically and skip steps 1 and 2 entirely. The result is very efficient, highly automated processes that shouldn't exist.
AI coding agents make this worse in a precise way: they make step 5 nearly free. When generating code costs nothing, the default becomes "add." The algorithm is the counterweight.
Here's what it looks like applied to three places that cost real money.
Security teams usually think in controls. I'd argue the more useful frame is parts count: every route, table, credential, permission, open port and integration is a part that can fail open.
In September 2026, UpGuard published the largest study yet of Supabase misconfiguration. It identified 16,326 databases exposing readable tables, and 55.8% of them showed indicators of personal data (UpGuard Research; BleepingComputer). UpGuard notes that Supabase now enables row-level security by default for tables created in its Table Editor, but tables created programmatically, "which is how coding agents interact with Supabase," don't get RLS by default.
Run the algorithm on that failure:
anon and authenticated roles by default,
-- Delete first: nothing is reachable until someone names why it should be.
revoke all on all tables in schema public from anon, authenticated;
-- Then add back, deliberately, the few paths that have a named owner.
grant select on public.products to anon; -- owner: storefront (Michael)
grant select, insert on public.orders to authenticated;
alter table public.orders enable row level security;
create policy "own orders" on public.orders
for select to authenticated
using ((select auth.uid()) = user_id);
That's step 2 with the 10% add-back rule built in. Default-deny isn't a security philosophy. It's the algorithm applied to permissions.
Here's an infrastructure example from this month. Vercel's classic Cron Jobs invoke your code through an HTTP GET to a public path, which means every scheduled job is also an internet-facing endpoint that you have to protect with a secret. On 5 November 2026 Vercel put Schedules into public beta. Schedules can target a private function that has no public URL, or a queue topic with retries (Vercel Schedules docs).
That's the platform deleting a part for you. A job that has no public URL can't be called by an attacker. The best auth check is the endpoint that doesn't exist.
Infrastructure bills are mostly the cost of parts nobody questioned: the poller that checks for changes every few seconds, the always-on worker, the duplicate pipeline, the dashboard query running on a timer for a dashboard nobody opens.
Let's do the math with published prices instead of hand-waving. On Vercel's Fluid compute, Pro pricing starts at $0.128 per Active CPU hour and $0.60 per million invocations (Vercel pricing; Fluid compute pricing).
Take a pattern that AI-generated front ends love: every open browser tab polls an API every 10 seconds to "stay fresh."
So that's roughly $340 a month before memory, database reads or egress, and the overwhelming majority of those requests return "nothing changed." Scale to 10,000 concurrent users and it's over $3,000 a month for the privilege of asking the same question 2.6 billion times.
Now apply the algorithm in order:
Most teams start at step 5: they set a budget alert on a design that's wasteful by construction.
Coding agents are extraordinary at step 5. Ask for a feature and you get the feature, plus an abstraction layer, three utility files, a retry wrapper, a new dependency and tests for all of it. Each piece is plausible, and together they're a lot of new parts.
Apply the algorithm to the diff, not just the product:
The SpaceX culture people admire is rapid iteration: build, test, learn, repeat. In software, step 4 (accelerate cycle time) only works if failure is cheap and contained. The best tool for that is decades old and still underused: the error budget.
Google's SRE book frames reliability as a budget to spend rather than a target to maximize: "100% is the wrong reliability target for basically everything," and the gap between the target and 100% is a budget that release velocity can use (Google SRE book, Introduction; see also Embracing Risk). Pair that with progressive delivery (feature flags, canaries, automatic rollback) and "move fast" stops being a slogan and becomes arithmetic.
The deletion step matters here too. Fewer parts means a smaller blast radius per change, which means you can afford to ship more changes. Deletion is what makes speed safe.
Here's the ritual I'd install in any engineering org. Once a quarter, for each category, list every item with a named owner and a one-line reason it exists:
| Category | Question | Default if no owner |
|---|---|---|
| Public endpoints and scheduled jobs | Who calls this, and does it need a public URL? | Make private or delete |
| Database grants and policies | Which role needs this, by name? | Revoke |
| Polling loops and timers | What breaks if this runs 10× less often? | Slow down or delete |
| Dependencies | What would we write in its place, and how big is it? | Remove if small |
| Feature flags | Is this flag still deciding anything? | Delete the flag and the dead branch |
| Agent and service credentials | What's the narrowest scope that still works? | Rotate and narrow |
Then hold yourself to Musk's metric: if you never have to add anything back, you didn't delete enough.
The highest-leverage engineering move in 2026 isn't writing code faster. AI already did that. It's having the discipline to delete faster than AI can generate.
Question the requirement. Delete the part. Then, and only then, make what's left fast and automatic. The best part is no part, the best endpoint is the one that doesn't exist, and the cheapest request is the one you never make.
Michael, ArkNet Digital: cloud architecture, security engineering and shipping AI-built software safely. arknet.digital
If your cloud bill or your attack surface grew faster than your product this year, I'm happy to run a deletion review with you. What's the biggest thing you've deleted that nobody missed? Tell me in the comments.