Agent-Driven Recombination To Build Integrated Tools Quickly

Issue 57 Edition 2026-02-26 6 min read

General

Sources: 1 • Confidence: Medium • Updated: 2026-03-02 19:33

Key takeaways

Collected working examples can be used as inputs for coding agents by prompting the agent to build new software by combining two or more existing examples.
Willison publishes notes as blog/TIL posts and maintains over a thousand GitHub repositories, many of them small proof-of-concepts.
Building software skill depends heavily on knowing what is possible and having a rough idea of how to accomplish it.
When using Claude Code, specifying curl can be necessary because the default WebFetch tool summarizes pages instead of returning raw HTML.
tools.simonwillison.net is a large collection of LLM-assisted HTML tools implemented as single HTML files with embedded JavaScript and CSS that solve specific problems.

Collected working examples can be used as inputs for coding agents by prompting the agent to build new software by combining two or more existing examples.
Willison built a browser-based OCR tool by combining code that uses PDF.js to render PDF pages as images and Tesseract.js (WebAssembly) to extract text from those images in JavaScript.
A single prompt that included both example codebases produced a working proof-of-concept HTML page that converted dropped PDFs into per-page JPEGs and ran OCR with results displayed beneath each image.
Coding agents can make the hoarding approach more powerful by fetching and reusing source code from the internet and local codebases as context for new tasks.
Iterating a few times with an LLM can quickly turn an LLM-generated proof-of-concept into a genuinely useful tool with lasting personal value.

Willison publishes notes as blog/TIL posts and maintains over a thousand GitHub repositories, many of them small proof-of-concepts.
tools.simonwillison.net is a large collection of LLM-assisted HTML tools implemented as single HTML files with embedded JavaScript and CSS that solve specific problems.
The simonw/research repository contains larger agent-driven examples where a coding agent researched a problem and returned working code plus a written report.
Willison often instructs agents to clone his public repositories to /tmp and mine them for examples to apply to new projects.

Building software skill depends heavily on knowing what is possible and having a rough idea of how to accomplish it.
Documenting a useful trick once with a working code example allows agents to consult it and solve similarly shaped projects in the future without re-deriving the technique.
Knowing something is theoretically possible is not equivalent to having personally seen it working as running code.

When using Claude Code, specifying curl can be necessary because the default WebFetch tool summarizes pages instead of returning raw HTML.

How often do hoarded runnable examples get reused successfully (by humans or agents), and what is the measured time/effort saved versus starting from scratch?
What failure modes occur when agents recombine examples (e.g., subtle bugs, licensing/IP issues, insecure patterns), and what controls mitigate them?
To what extent is the approach dependent on the tool format (e.g., single-file HTML) versus being broadly applicable to typical production stacks?
How reliable is agent web/code retrieval in practice, and how often do retrieval tools return incomplete or lossy representations that harm implementation accuracy?
What criteria define a 'useful trick' worth documenting, and what minimum documentation structure best enables future agent reuse (tests, examples, README detail)?

Tools that help agents reliably retrieve raw web and code artifacts could gain demand, since summarized retrieval can omit implementation details and users may need explicit raw fetch workflows.
Platforms that make runnable examples easy to store, search, and recombine may benefit if supplying known good exemplars meaningfully accelerates building integrated proof of concepts and small tools.
Single file, self contained tool packaging for small web utilities could see greater adoption if it proves a repeatable format for fast agent assisted shipping of narrow problem solvers.

Published measurements showing time or effort saved when agents recombine existing runnable examples versus starting from scratch, across multiple projects and users.
Documented controls and checklists that reduce recombination failure modes such as subtle bugs, insecure patterns, or licensing issues, with low incident rates over repeated use.
Evidence that raw retrieval reliability improves, such as fewer cases of lossy summarized content and more consistent access to complete HTML and code without manual workarounds.

Data showing reuse of hoarded runnable examples is rare, or that recombination yields little speedup due to integration complexity and debugging overhead.
Frequent recombination failures from security, correctness, or IP issues that require heavy human review, erasing the productivity advantage.
Findings that the approach depends strongly on niche formats like single file HTML and does not translate well to common production stacks.