I don’t really use libraries anymore

SUMMARY

Theo Browne, a full-stack developer and t3.gg creator, examines how AI tools are reducing reliance on software libraries by enabling custom code generation, sharing anecdotes from his projects and industry trends.

STATEMENTS

AI is rapidly transforming software development, with both positive and negative implications, particularly regarding the role of libraries.
Developers have historically used libraries like those in npm to quickly solve problems, even simple ones like left-padding text or checking if a number is odd.
This convenience has led to laziness, as developers often integrate libraries without fully understanding them, similar to current AI usage patterns.
In recent projects, Theo has removed problematic libraries, finding it easier to rewrite them using AI prompts than to troubleshoot issues.
For T3 Chat's Wrapped feature, the library Tkumi failed in production bundling, prompting Theo to rewrite it as client-side JavaScript via AI.
Antirez, Redis creator, replaced a 4,000-line C++ library in Redis with a 400-line AI-generated pure C implementation, tested rigorously.
This trend will alter project structures and package.json files, making external libraries less essential.
Critics of tiny libraries like is-odd or leftpad argue they outsource basic competency and introduce risks like supply chain attacks.
AI code generation addresses these issues by allowing developers to create simple solutions without external dependencies, reducing risks for less experienced coders.
Larger libraries like Tkumi handle complex tasks such as server-side React rendering to images but can cause deployment headaches.
Theo categorizes libraries into those beyond a developer's knowledge (for beginners), tedious to implement (e.g., state management), and those requiring maintenance like Next.js.
AI lowers the barrier for reimplementing tedious tasks, shifting the cost-benefit analysis toward custom solutions.
Projects like Convex integrate well with AI because their code lives in the developer's codebase, easing modifications.
Prompt requests, where developers share AI prompts instead of pull requests, reveal intent better than code diffs, as suggested by Sty Pete.
Libraries often include unwanted features, but AI allows tailored implementations without bloat.
Perceived risks of dependencies have increased due to npm exploits, while AI makes implementation easier, favoring in-house code.
Open-source maintenance is unsustainable, and AI exacerbates this by enabling more people to code but also increasing library usage among novices.
Tools like Shadcn copy components directly into codebases, improving AI compatibility over external packages.
Prompts are emerging as the new "libraries," with examples like cleaning agent.md files via shared prompts.

IDEAS

AI enables replacing entire libraries with custom code, turning dependency management into a prompt-based process.
Tiny libraries like leftpad persist in popularity despite built-in alternatives, driven by novice developers using AI to code more.
Prompt requests could supplant pull requests, as sharing the AI instruction reveals intent more clearly than code changes.
Developers now use libraries as references to prompt AI agents for bespoke implementations, avoiding bloat.
The math for adopting libraries has flipped: easier AI implementation raises perceived dependency risks.
Open-source burnout worsens with AI, as more inexperienced users demand maintenance without contributing.
Forking or rewriting libraries internally, as Anthropic did with Ink for Claude Code, becomes feasible with AI assistance.
Acquiring core dependencies like Bun makes sense for companies when they wrap the entire project stack.
Having code in your repo outperforms external docs for AI tools, as agents navigate source better than scattered documentation.
Well-documented, simple libraries are easiest for AI to replicate, ironically making them prime candidates for replacement.
Prompts shared like code snippets could become the standard for collaboration, reducing the need for packaged solutions.
AI shifts library value from solving annoying problems to providing prompts that guide custom builds.
Tools like BTCA clone codebases for AI analysis, making in-house code far superior to relying on outdated external resources.
Popularity of libraries like Ink surges with AI due to React familiarity, but limitations prompt forks.
Developers increasingly prefer vibe-coding alternatives for control, even if it means performance trade-offs.
The incentive for new libraries diminishes as AI favors known, replicable patterns over novel ones.

INSIGHTS

AI democratizes coding but amplifies risks by empowering novices to bloat projects with unnecessary dependencies.
Custom AI-generated code enhances maintainability by embedding solutions directly, reducing external failure points.
The sustainability of open source hinges on redefining contributions, as AI eases creation but burdens maintainers.
Prompt-based development prioritizes intent over implementation, fostering clearer collaboration in teams.
Libraries' value now lies in their documentation as AI training fodder, not the code itself.
Risk assessment for dependencies must account for AI's ability to fork or replace, altering adoption thresholds.
In-house codebases become AI's preferred context, turning copy-paste tools like Shadcn into strategic advantages.
As coding accessibility rises, the ecosystem tilts toward shared prompts over proprietary packages.
Companies like Anthropic exemplify strategic dependency management: rewrite the replaceable, acquire the essential.
The irony of AI: it solves library overuse for experts while potentially increasing it for beginners.

QUOTES

"I've been changing a lot of things in the projects that I work in, including things like removing libraries that no longer really make sense or cause us problems."
"This PR removes 4,000 lines of code and only adds 400. And as he says in the description, this code was written by cloud code using opus 4.5 and tested carefully."
"I don't like pull requests anymore. A large chunk of code change doesn't tell me much about the intent or why it was done. I now prefer prompt requests."
"The same things that made one of these packages worth installing now make the package worth replacing."
"Prompts are kind of becoming the new library."

HABITS

Regularly audit dependencies in projects to identify and remove problematic libraries using AI for replacements.
Use AI tools like Claude for initial code generation, then manually refine for complex tasks like layout and aesthetics.
Integrate AI code reviewers such as Code Rabbit into workflows for instant feedback in IDEs and CLIs.
Share prompts instead of code in collaborations to convey intent and allow others to adapt solutions.
Prioritize copying components directly into codebases, as with Shadcn, to enhance AI compatibility and control.
Test AI-generated code rigorously against originals, combining manual and synthetic methods.

FACTS

The leftpad library remains popular despite JavaScript now having built-in string padding functions.
Redis pull request replaced a 4,000-line C++ library with 400 lines of AI-generated C code.
T3 Chat's production instance experienced a 25-second outage due to Tkumi bundling issues on Vercel.
Ink library's popularity has skyrocketed due to AI-driven CLI development, despite its single part-time maintainer.
Anthropic acquired Bun to secure a core dependency that wraps their Claude Code project.
Is-odd library downloads have not declined, even as AI enables simple one-line alternatives.
Open-source projects like FFmpeg persist due to unsustainable funding models and maintainer burnout.

REFERENCES

Tkumi: Rust library for JSX-to-image rendering of React components.
Redis: Open-source database with recent PR gutting C++ libraries for pure C via AI.
Code Rabbit: AI-powered code review tool with CLI and IDE integrations.
Claude Code: Anthropic's agentic coding tool using internal Ink alternative.
Antirez: Redis creator implementing AI-assisted library removals.
Sty Pete: Open-source developer advocating prompt requests over pull requests.
Next.js: Framework for extensible web apps with server rendering and SEO features.
Convex: Database and compute platform integrating well with AI for real-time sync.
Ink: React for CLI library, forked internally by companies like Anthropic.
Bun: JavaScript runtime acquired by Anthropic for binary packaging.
Shadcn: UI component library that copies code directly into projects.
BTCA: Tool by Theo's channel manager for cloning codebases to aid AI analysis.
Simon Willison: Developer noting AI reduces need for libraries solving frustrating problems.

HOW TO APPLY

Assess each library's complexity against your capability: replace simple ones with AI-generated code to avoid risks.
When facing deployment issues, prompt an AI agent to rewrite the functionality, testing client-side alternatives first.
Categorize dependencies by need—beyond knowledge (use established like Next.js), tedious (vibe-code if possible), or core (fund or fork).
Shift collaboration to prompt requests: share AI instructions for features instead of code diffs to clarify intent.
Audit package.json for bloat: use libraries as references to generate tailored in-house versions without extras.
Integrate codebase-cloning tools like BTCA for AI reviews, prioritizing source code over external docs for accuracy.

ONE-SENTENCE TAKEAWAY

AI empowers developers to replace libraries with custom code, reducing risks and reshaping software dependency landscapes.

RECOMMENDATIONS

Replace trivial libraries like is-odd with AI-generated snippets to build core competencies and minimize supply chain vulnerabilities.
For complex integrations, evaluate AI rewriting versus maintenance costs, prioritizing control in production environments.
Adopt prompt-sharing in teams to enhance transparency, using tools like Claude for iterative refinements.
Fork or fund critical open-source dependencies if they underpin your stack, as exemplified by Anthropic's Bun acquisition.
Use copy-paste libraries like Shadcn to embed UI components directly, improving AI agent performance on your codebase.
Regularly test AI outputs against library benchmarks to ensure reliability before deployment.
Avoid over-relying on external docs; clone and analyze codebases with tools like BTCA for better AI insights.
Rethink library adoption math: weigh increased implementation ease against heightened perceived risks from exploits.
Promote maintainer contributions in vital projects, or build alternatives to prevent burnout in the AI era.

MEMO

In the evolving landscape of software development, AI is quietly eroding the foundational role of libraries, once the lifeblood of efficient coding. Theo Browne, the influential creator behind t3.gg, reflects on this shift in a candid video, drawing from his hands-on battles with dependencies in projects like T3 Chat. What began as a meme-worthy habit of npm-installing solutions—even for absurdly simple tasks like left-padding strings or checking parity—has given way to a more discerning era. Browne recounts wrestling with Tkumi, a Rust-based tool for rendering React components into images, which repeatedly failed in production on platforms like Vercel, causing brief outages. Frustrated after 15 minutes of debugging, he turned to "vibe coding"—AI-assisted rewriting—transforming it into client-side JavaScript. This personal anecdote underscores a broader trend: AI tools like Claude are making it not just possible, but preferable, to excise problematic libraries rather than patch them.

The irony is palpable. Critics have long lambasted JavaScript ecosystems for fostering laziness through micro-libraries, outsourcing basic skills and inviting risks like supply chain attacks. Yet AI, often derided by the same skeptics, emerges as the antidote. Browne highlights how novices, empowered by chat interfaces, can generate two-line functions without external crutches, sidestepping malicious updates or version breaks. Even Redis's creator, Antirez, embodies this pivot: a pull request slashed 4,000 lines of C++ code for a floating-point library, replacing it with a lean 400-line AI-crafted C version, rigorously tested against the original. Such moves slim down package.json files and bolster security, but they also reveal fractures in open source. As AI lowers barriers, more inexperienced developers flood in, ironically boosting library downloads—leftpad persists despite native JavaScript alternatives—while maintainers burn out under unchecked demands.

Browne categorizes libraries by developer expertise: beginners grasp for those beyond their ken, veterans shun tedious reimplementations unless truly necessary, like robust state management in React. Tools like Next.js endure for their extensibility—handling SEO, sessions, and server rendering with decades of refinement—yet even these face scrutiny. AI bends the adoption curve: what was once too arduous now yields to prompts, using libraries merely as blueprints. Sty Pete's radical proposal of "prompt requests" over pull requests captures this ethos, prioritizing intent-sharing for collaborative builds. Meanwhile, giants like Anthropic fork Ink for Claude Code's CLI needs, deeming it replaceable, while acquiring Bun to secure a runtime that envelops their stack. This strategic calculus—rewrite the peripheral, own the core—signals a future where dependencies are audited not just for utility, but for forkability.

The ripple effects extend to collaboration and sustainability. Browne praises Shadcn for pasting UI components directly into codebases, making them AI-friendly and sidestepping external bloat. Tools like BTCA, built by his team, clone repos for agent analysis, proving far superior to parsing outdated docs. Simon Willison echoes this, noting he'd no longer craft libraries for annoyingly fiddly tasks like S3 credential management—AI handles IAM policies adeptly now. As prompts supplant packages, the incentive for novel libraries wanes; why invent when agents replicate the familiar? Yet this democratizes creation at a cost: open source's financial woes deepen, with AI-fueled hordes amplifying support burdens without reciprocity.

Ultimately, Browne urges a reevaluation of every dependency: Does it hold you back? Is it worth the risk? In this AI-accelerated world, the nerds who once mocked npm excess may find themselves vibe-coding their way to cleaner, more sovereign codebases. The excitement lies in the empowerment, the scariness in the unknowns—but one thing is clear: software's building blocks are fragmenting, and prompts may soon be the mortar holding them together.