Code Is Cheap Now

Overview

OpenAI just posted a GitHub discussion about shutting down community pull requests on Codex. They haven't done it yet — but the reasoning they laid out says everything. In their words, "code itself is no longer the scarce resource." The company that built the AI coding tools is telling you that typing code isn't the hard part anymore. And I've been saying this for a while.

The GitHub Issue That Sparked This

I came across this GitHub discussion from OpenAI, and it immediately caught my attention. Eric Traut from OpenAI posted a discussion titled "Updating Codex Contribution Guidelines" where they're basically saying they want to shut down community pull requests on Codex.

Their proposed change:

We are updating our contribution guidelines to move to an invitation-only model for code contributions. We no longer accept unsolicited pull requests.

Now that's interesting, right? The company that created the AI coding tools is now saying they don't want people to contribute code. And why? Not because people can't code — that's not the issue. It's because too many people are writing code that misses the point.

While we deeply appreciate the time and enthusiasm behind these contributions, we've found that reviewing, correcting, and integrating external PRs often takes more effort than implementing the same fixes directly. In many cases, PRs focus on low-priority issues or are difficult to evaluate without additional architectural context or insight into the project's roadmap.

Community PRs have become "a bottleneck rather than a force multiplier."

Code Is Cheap. Let That Sink In.

Here's the line that says it all:

In an AI-accelerated world, code itself is no longer the scarce resource. Understanding the problem, identifying the right solution, and making good prioritization decisions are the hard parts.

OpenAI, the company that built Codex, is saying code doesn't matter. Well — they're not saying code doesn't matter. They're saying the typing of the code doesn't matter anymore.

And I've been saying this for a while now. It has not been about how fast you can type your syntax. It's never been about who can crank out the most lines of code.

So what's the major shift we're seeing here? Code is cheap. It really is. Syntax is cheap. It's the planning that matters.

You're Using AI Wrong

I still continually get feedback in my YouTube comments from people saying AI can't get the job done. And I really feel for these people, but I'm telling you — you're using AI wrong.

If you are not using AI to accelerate your coding, you're just using it wrong. There's no question at this point. I have shipped more code in the last six months than I probably have in the last two years, and that is because I'm using AI properly.

I'm not shipping slop code. I'm not shipping garbage code that won't scale. This is all enterprise-ready code using the same standards that I've used for the last decade. It's just that AI understands how I want it to write it.

It's because of the planning, because of the skills, because of all the things that I make AI learn to do. And what happens when it's done is AI now writes code like I do. AI doesn't write code like the internet says — because most of the Go code out there on the internet is complete garbage.

What's Going to Happen?

We're going to see what happens with this issue. I'm keeping an eye on it. I'm very curious to see if they actually stop accepting pull requests. Because at this point it's not about typing the syntax — it's about the planning and the roadmaps.

What the Community Is Saying

The discussion has sparked some interesting reactions. Let's break them down.

The Irony Take

Bad3r put it bluntly:

TLDR: because of AI; which we helped create and popularize and advertise as a good tool for coding, we don't accept contributions. How ironic.

Fair point. OpenAI built the tools that made it trivially easy to generate code, and now they're dealing with the consequences. That sparked a heated reply thread — one commenter defended OpenAI saying they can just use AI themselves instead of accepting lower-quality external code. Which honestly reinforces the whole point.

The "This Makes Sense" Crowd

GuangmingLuo agreed immediately, pointing out it was always considered rude to submit a PR directly without first discussing it via an issue — especially for first-time contributors. That's basic open-source etiquette that a lot of AI-generated drive-by PRs are ignoring.

pavan-sh nailed the summary in one line:

This makes sense. In 2026, implementation is cheap; reviewer attention + roadmap context isn't.

The Nuanced Pushback

The most thoughtful response came from dagelf, who raised a valid counterpoint:

Sometimes a pull request/fix IS the most concise description and review of the problem. Now even more so.

They argued that many people who submit bug reports aren't technically proficient enough to describe what they're seeing, and that a well-crafted PR can actually be the clearest way to communicate a fix. They also raised the community angle — the contributor ecosystem is important to grow and conserve, and that window might close naturally. Why rush it?

It's a fair point, and it highlights the tension here. OpenAI's not wrong that low-effort AI-generated PRs are noise. But completely shutting the door on code contributions also means losing the signal from people who genuinely understand the problem and can express it best through code.

Even the Docs Are AI-Generated

Here's a detail that flew under the radar. When someone asked about contributing documentation, OpenAI's Eric Traut revealed that their documentation lives in a private repo and:

Many of the updates are automated by Codex. The code base is changing so quickly that it would be almost impossible to keep up with documentation changes if we had to do it manually.

Even the documentation is being written by AI. The humans are focused on architecture, prioritization, and review. That tells you everything about where OpenAI sees the value chain.

Our Job Hasn't Changed

I want to be really clear about this. Our job as software engineers has not changed. We design, we plan, we debug. What we just don't do as much anymore is the typing.

We do everything else that a senior software engineer still has to do. We pick the tech stack, we find the tools we want to use, we do the research, and then we make sure this is the code that we actually want. We don't let AI go off on a wild goose chase and just make things up as we go.

Senior engineers tell AI how to work, not the other way around.