AI is churning out code at breakneck speed, and everyone’s jumping on the bandwagon. But what happens when we let the machines do the typing? As someone deep in the trenches of web development, I’ve been watching this unfold with equal parts fascination and concern.
I’ve witnessed the WordPress ecosystem transform almost overnight as developers increasingly ask Claude, ChatGPT, or whatever shiny new LLM has dropped this month to handle their coding tasks. Need a custom post type? An LLM can spit it out faster than you can say “register_post_type” — certainly faster than you can search the plugin directory and evaluate options. Want some CSS without the headache? The AI will take a first crack while you grab coffee, giving you something to refine rather than a blank slate to stare at.
It goes deeper, too, extending well beyond these surface-level conveniences. Why struggle with complex data migrations when you can have an AI write you a custom WP-CLI command tailored to your exact specifications? Why spend hours figuring out how WP All Import works when an AI can craft a bespoke solution in minutes? The appeal is undeniable—instant solutions without diving into documentation or wrestling with someone else’s plugin that does almost, but not quite, what you need.
This rapid shift in development practices isn’t unique to WordPress, of course. Across the programming landscape, developers are discovering the time-saving magic of having an AI assistant that can translate their intentions into functional code with minimal fuss. It’s like having a junior developer who works at the speed of light and never needs a coffee break.
When AI code generation first hit its stride, open source advocates celebrated: “This will be revolutionary for open projects!” The logic seemed sound—LLMs excel at generating code for frameworks like React, Express, and WordPress partly because these projects have mountains of publicly available code examples. Open codebases provide the very training material that makes these models effective, so it made sense that open projects would reap the greatest rewards from AI assistance.
But is simply generating more downstream private code actually benefiting the open source ecosystem? When a developer asks an LLM to create a WordPress plugin that they’ll use once for a specific client need and never share back with the community, is that really advancing open source? Or is it just extracting value without reciprocating?
Here’s where it gets interesting: proprietary systems are likely seeing similar benefits. Once LLMs understand programming’s fundamental structures, the openness of the original codebase becomes less relevant. A company running on a closed-source stack probably has enough internal code examples to feed to an LLM and get equally impressive results. The machines are learning to code, period—not just to code in open frameworks.
Don’t get me wrong—AI is far from a perfect developer. It shines with small, concrete tasks but stumbles when dealing with large codebases or complex features. It can build something new with surprising competence but struggles with maintenance tasks and often introduces subtle bugs that only emerge later. Ask it to add a feature to an existing codebase, and you might end up with beautiful code that completely misunderstands the project’s architecture or introduces security vulnerabilities that won’t be apparent until production.
For projects like WordPress—already drowning in over a thousand unreviewed pull requests—more code isn’t necessarily what’s needed most. The bottleneck isn’t code generation; it’s thoughtful review, strategic direction, and the human wisdom to know which features should be built in the first place.
This raises a question that keeps me up at night: What might open source be losing in the age of AI-generated code?
Before AI, if I needed to solve a problem, I had two primary options: write the solution myself or find someone else’s code to use or modify. This second path often led me down a rabbit hole of discovery. I’d find a plugin or library that almost worked, dig into its code, learn how it approached the problem, and then either adapt it or create my own solution informed by what I’d learned. I might publish my improvements or send them back as a pull request. This exchange—this public collaboration—is the lifeblood of open source. It’s not just about using code; it’s about improving it together in the sunshine.
When developers skip the search for existing solutions and jump straight to AI generation, something valuable is lost in that process. The serendipitous discovery of projects you didn’t know existed. The appreciation for another developer’s elegant solution to a problem you’ve been struggling with. The community connections formed when you contribute back improvements. All of these become rarer in a world where private AI conversations replace public code repositories as our first stop when solving problems.
Open source thrives when developers take those extra minutes to make their solutions universal and shareable. It builds community when we publish our work publicly so others can build upon it. The magic happens when the best solutions bubble up through collective effort and gain widespread adoption. This virtuous cycle has given us the digital infrastructure that powers modern computing—but it requires participation to sustain itself.
While established open source projects will likely continue to thrive, I worry about the disappearing on-ramp for new contributors. How do you become a valued open source contributor if you never need to read other people’s code because an AI can explain everything? How do you develop the habit of sharing your solutions if every problem is solved in a private conversation with a machine?
WordPress itself has become increasingly challenging for newcomers to contribute to—partly due to the shift from PHP to React/JavaScript, which raised the technical bar substantially, but also because repositories like Gutenberg operate more like rapid prototyping labs than welcoming community spaces. Documentation lags behind implementation, features appear and vanish mysteriously, and getting answers often means awkwardly tagging strangers on Twitter rather than consulting proper resources.
In this environment, AI might seem like a savior—helping developers navigate complexity without needing to understand every nuance. But that surface-level understanding rarely translates to meaningful contributions. You can’t effectively guide a project’s direction without the deep knowledge that comes from struggling with its codebase over time.
What open source truly needs isn’t just more code—AI has that covered. It needs knowledgeable humans who can lead projects, make thoughtful decisions, exhibit good taste, maintain ownership over features, and welcome newcomers. As Brooks argued in The Mythical Man-Month, throwing more manpower (or in this case, machine power) at a project often increases communication overhead faster than it resolves coding challenges. The bottleneck in mature open source projects isn’t usually code production but coordination and decision-making—things AI currently does poorly.
AI might generate code summaries or even scan issue threads, but it can’t develop the deep understanding needed for meaningful project decisions. It can’t feel the pain points that should drive prioritization. It can’t build consensus among stakeholders with different needs. The path to becoming a valuable contributor isn’t just about understanding code—it’s about absorbing the culture of collaboration that makes open source work.
I’m not suggesting we abandon AI tools—that would be like refusing to use power tools because hand saws build character. There’s nothing inherently wrong with using AI-generated code—I rely on it regularly myself, and it’s unquestionably making certain aspects of development more efficient. But I’d encourage all developers to remember the true value of open source: it’s not just the code you take, but the code you give back. And more importantly, it’s the relationships you build with contributors across the globe as you collectively craft something better than any individual—or machine—could create alone.
Perhaps the answer lies in finding ways to integrate AI assistance without losing the collaborative essence of open source. Maybe we need AI tools that don’t just generate code but help us discover related projects. Tools that encourage us to contribute back improvements rather than generating one-off solutions. Tools that facilitate human connections rather than replacing them.
We might be gaining efficiency, but are we losing the collaborative spirit that makes open source special? That’s the question we need to answer before the robots do all our typing. And unlike most coding challenges, this isn’t something we can simply outsource to an AI—it requires human wisdom, foresight, and a commitment to preserving what makes open source valuable beyond just the code itself.
In the meantime, next time you ask an LLM to generate that WordPress plugin, consider taking a few extra minutes to package it up and share it with the community. The future of open source might depend on such small acts of generosity.