
AI Β· 14 min read
What We Build With AI Today Is Tomorrow's Legacy and Attack Surface
On this page
Calif ended their Java4Shell write-up with a question I keep coming back to:
With AI, everyone is asking, “What can we build?” But maybe the right question for security is, “What can we delete?” [1]
So I counted. Since February I have added 75 skills to my own agent toolkit. I have deleted zero.
That toolkit is not a side project. It is my personal agent harness, and almost every tool I use in a working day runs on it: the local dashboards I check in the morning, a morning brief that pulls my calendar and mail together, mail triage, the analytics for this blog, the review page I read my drafts in, and the scripts that build the walkthrough videos for my posts. Each skill took away a chore I used to do by hand, which is why I kept building. It is also why the pile grew.
That number didn’t surprise me as much as it should have. I’ve been building a lot, and not all of it is used anymore. Some ideas got built and never used. Sometimes the agent even tells me that we already have the new thing I’m asking it to build. Calif’s question was aimed at shared software stacks like Java. I think it applies just as much to the small tools we now build for ourselves.
What Java4Shell Is
Java4Shell (CVE-2026-114938) is a memory-corruption bug in OpenJDK’s hand-written x86-64 Base64 decoder, one of the intrinsics HotSpot uses to make hot code paths faster. Calif rates it 9.2 out of 10 under CVSS 4.0 [1]. OpenJDK’s own advisory scores it 8.1 under CVSS 3.1 [2]. Either way, it is serious. The short version:
- A malformed input (64
Acharacters followed by a single=) makes the fast path compute a negative output length. The decoder then writes 62 bytes past the end of a 50-byte array before Java rejects the input [1]. - Calif turned that fixed-value overwrite into a heap leak and remote code execution, and demonstrated it against several widely deployed Java applications in their default configuration. The full chain is in their write-up [1].
- Calif says it affects OpenJDK from 17.0.6 onwards, up to the releases fixed in November 2026, and the distributions built from it, such as Amazon Corretto, Eclipse Temurin and Azul Zulu [1]. OpenJDK’s advisory lists 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, 27.0.1.0.3 and earlier as the affected versions for that release [2]. Even on an affected version, it only triggers on x86-64 CPUs with AVX-512 VBMI. ARM64 is not affected [1].
OpenJDK published its advisory and fixes on 17 November 2026 [2]. Update first. If you can’t update right away, Calif lists two startup flags as mitigations: -XX:-UseBASE64Intrinsics turns off the hardware-accelerated Base64 code, and -XX:UseAVX=2 turns off AVX-512 (x86-64 only, because OpenJDK on ARM fails to start with it) [1].
If your Java applications sit behind AWS WAF, there is one more way to buy time while you patch. On the same day, AWS released version 1.28 of the Known bad inputs managed rule group, with three new rules (Java4Shell_BODY, Java4Shell_QUERYARGUMENTS and Java4Shell_HEADER) that match Java4Shell patterns in inspected request bodies, query arguments and headers for CVE-2026-114938 [9]. They are a supplementary, signature-based control, not complete coverage of every exploit. They ship with the Count action, so you need to select that version and override the rules to Block. A WAF rule only covers HTTP traffic that passes through it, and it does not replace the update.
A Fast Path Few Applications Needed
Calif’s argument is about the commons. Java has grown to serve many needs, and each feature request makes sense on its own. But everyone inherits the code. In Calif’s words, the Base64 optimization “helps applications that decode enormous amounts of data”, yet it ships to everyone else too, and “an optimization few applications needed became a serious security risk” [1].
Their answer is what they call vibe-uncoding: use the same AI that finds the bugs to comb a codebase for dead code, bloated features and needless optimizations, then “identify the parts a system actually needs, then remove everything else to reduce its attack surface” [1]. The term is theirs, and I’m borrowing it.
They also mention Squidbleed, a bug that had been hiding in Squid’s FTP module since 1997 [1]. That one fits the usual picture of legacy code. Java4Shell doesn’t. OpenJDK 17.0.6 shipped with the January 2023 update [3], so the affected code is less than four years old. So I’d stop measuring legacy code by its age. What makes code legacy is that few people need it and nobody looks at it, and a four-year-old fast path can get there quickly.
What the Java4Shell Search Cost
For everyone who doesn’t maintain a JDK, the most important number in the disclosure is the cost. Quang Luong at Calif pointed Codex at the JIT compiler, intrinsics and cryptography. It took about an hour to find the vulnerability, two more hours to build the first working exploit, and less than $200 in tokens [1].
For a long time, code nobody looked at was partly protected by how much effort it took to look. This is one case, and the person running Codex knew what to look for and how to turn a bug into an exploit. Still, it shows that an expert with an agent can work through an obscure, security-sensitive corner of a large system in hours, for a few hundred dollars. I expect more people to try the same on the corners that a system’s own maintainers skipped.
And forgotten code keeps its bugs for a long time. Log4Shell is the precedent. In 2025, developers pulled Log4j from Maven Central nearly 300 million times, and about 13% of those downloads still contained Log4Shell, almost four years after fixed versions were available [4]. Sonatype’s list of reasons includes “set-and-forget dependencies that no one revisits once they compile” [4].
We Now Write Our Own Long Tail
Here is where I want to take Calif’s point further. The commons problem used to belong mostly to shared stacks: the JDK, the frameworks, the libraries we all pull in. AI coding agents made bespoke software cheap enough that the audience for a tool can be a single person. So now each of us is creating our own long tail. A personal tool may never face the internet, but it can run with its author’s credentials and access, on a schedule, without anyone else reviewing it. Mine do. My 10 background jobs are user launch agents on my Mac, so they run as me, and nobody but me reviews my personal skills.
Today’s Code Is Tomorrow’s Legacy
We tend to talk about security bugs as a legacy problem: old code, old protocols, a module from 1997 that nobody remembers. Java4Shell shows that legacy is a state, not an age. And that changes how I look at what we build with AI right now, because every tool we vibe-code today is a candidate for tomorrow’s legacy.
The volume is new. GitHub’s Octoverse 2026 counts 34.3 billion commits in the past 12 months, more than three times where they stood two years ago. From June onwards, about 55% of all commits came from brand-new repositories, and among repos created this year, the average one with an agent configuration file logged eight times as many commits as the average one without [5]. Tripling every two years is compound growth. If that pace holds, the yearly output grows exponentially, and the pile of code we have to own grows even faster, because each year’s output adds to everything from the years before. Almost none of it gets deleted.
Only the last 12 months are measured. The 2024 point is an upper bound derived from GitHub’s statement of more than three times, 2025 is interpolated, and the dashed lines continue an assumed tripling every two years. A scenario, not a forecast.
I’m not arguing that we should build less. I’m not going to stop, and I don’t think you should either. I’d like us to delete as deliberately as we build.
Disposable Software That Never Gets Disposed Of
Some people call the cheap, bespoke kind of software disposable. Tian Pan’s version is “write it, run it, delete it”, a fifty-line script that runs once and disappears. He puts it well: “Deleting the script isn’t waste; it’s the whole point.” [6]
For that script, I agree. My problem is with the tools that stick. Once something has been useful once, it gets a name, a folder and maybe a scheduled job, and from then on nobody deletes it. In March I wrote that with a capable coding agent “the specialized agent becomes a temporary script” [7]. Most of what I built since then is still in my setup, and I can’t tell you which of it still runs.
What I Added and Deleted Since February
Here is what that looks like for me. My agent toolkit lives in one Git repository whose first commit is from 2 February 2026. It holds the dashboards, briefs and scripts I described at the start. None of it was planned as a product. Each piece started as “can you build me something that⦔ and stayed. This is my disposable software. Yours will look different: a few notebooks, a Slack bot for the team, a dashboard over a spreadsheet, a set of shell scripts a coding agent wrote for you last spring. The question is the same.
These numbers were counted on 18 November 2026:
- 71 personal skills in the folder today, plus 41 shared core and beta skills
- 34 agent configurations
- 10 scheduled background jobs
- 459 script files under
scripts/
The Git history shows the direction:
Personal skills: 75 added, 0 deleted. Script files: 814 added, 35 deleted.scripts/ are probably most of the gap, and my count doesn’t separate them, so I don’t lean on the script figures. The skill count is clean. I added 75, 71 are still there, 4 were moved and none were deleted.
What Git Can Tell Me About Usage
So which of those tools could I delete? Git offers a tempting answer: 22 of my personal skills have not been edited for more than 60 days, and the oldest one has not been touched for 257 days.
That doesn’t mean they are unused. A skill nobody edits may run every day because it works. Another may have been dead since the week I built it. Git only sees a tool when someone changes it, and running a skill changes nothing.
This is also why the agent sometimes tells me “we already have this”. It can see what exists, because the files are right there. Nothing in my setup can see what gets used, because I never counted. Without that signal we can’t answer “what can we delete?”. We can only guess, and a guess is a good way to delete the monthly job you forgot you depend on.
Counters and a Monthly Review
The fix I like best came from a conversation at a recent meetup. Someone described an automatic weekly or monthly check of what was used, based on simple counters, so the team reviews the least-used things first. It’s cheap to start:
- Inventory what you built with your agent: skills, scripts, scheduled jobs, hooks. The agent is good at this part.
- Add a usage signal. One log line with a timestamp every time a tool runs is enough. Keep it local and record only the tool’s name and the time, not its inputs.
- Schedule a review, monthly or weekly, sorted by least used. Let the agent prepare the delete list. A person decides for each item: keep, archive or delete.
Build, use, count, review. Whatever stays keeps its counter, and next month the list is sorted again.
A tool can also be rarely used and still needed. One for a yearly task will look dead in every monthly review but one. Read the counter over a longer window, and mark tools that are rare on purpose so the review skips them.
I don’t have those counters yet. My count above is the “before” picture, and adding them is my next change. Once they run, I’ll build the review list from usage and ignore how old a file is.
Where to Start
Calif’s question was “what can we delete?”, and for the code we wrote for ourselves nobody else is going to ask it. That makes our own tools the easiest place to practise vibe-uncoding. Earlier this year I argued that coding agents need security agents next to them [8]. A usage counter and a monthly delete list are a smaller step in the same direction, and you can start this week. I’ll report what my counters show once they have run for a few months.
π¬ When did you last delete a tool you built with an agent? And if you added a counter today, what do you think it would show next month?
Sources
- [1] Calif β “Java4Shell: Write once, RCE everywhere” β the closing question, the commons and vibe-uncoding argument, bug details, cost, affected versions and mitigations
- [2] OpenJDK Vulnerability Advisory 2026/11/17 β fixed versions and the CVSS 3.1 score for CVE-2026-114938
- [3] OpenJDK Vulnerability Advisory 2023/01/17 β the January 2023 update that followed 17.0.5, i.e. the 17.0.6 release
- [4] Sonatype β “Unnecessary Risk: The Persistence of Open Source Vulnerabilities” β Log4j downloads in 2025 that still contained Log4Shell
- [5] GitHub β “Octoverse: Commits, pushes reach new highs in 2026 as developers build with agents” β commit and new-repository numbers
- [6] Tian Pan β “Single-Use Software: Write It, Run It, Delete It” (2 July 2026)
- [7] My earlier post β “The Coding Agent That Doesn’t Code”
- [8] My earlier post β “Security Is Job Zero, Even (Especially) in the Age of Coding Agents”
- [9] AWS WAF Developer Guide β “AWS Managed Rules changelog” β Known bad inputs rule group version 1.28 (17 Nov 2026) with the Java4Shell rules
β€ Created with the support of AI (Kiro)