AI is Not Taking Over Coding Jobs.

A strong coding agent can now produce a working program in seconds, which makes it easy to confuse code generation with software engineering. I ran into that problem while turning my Poker Basic Strategy model into Python using GPT Sol in Codex at high effort. The program looked clean, the functions were organized, the inputs were validated, and the output looked reasonable enough that I trusted it before I had actually reviewed it.

Codex clearly understood the strategy itself. My original model gave suited cards a five point bonus, and Codex reduced that to two points, bringing the heuristic much closer to the actual mathematical value of suitedness. It was not simply copying instructions into Python. It was reasoning about the model well enough to improve part of it.

Then it made a much simpler mistake in the implementation.

The postflop code forced the user to choose only one condition at a time: no flush draw, top pair, low pair, missed pair, or no adjustment. Poker does not work that way. A player can hit top pair and also have no flush draw on the same flop, so both adjustments may need to apply.

The part that made the mistake sting was where I sent it, trusting the AI. I had attached the program to an email to MIT Pokerbots and Paco Gomez Paz, Professor of MIT Independent Activities Period course 6.9630, Pokerbots. I did not first reading the code closely enough to catch the flaw myself. That meant I had effectively handed a poker programming instructor and people around an MIT coding competition a program that treated “top pair” and “no flush draw” as if only one could happen on a flop.

The irony was brutal: Codex had been sophisticated enough to refine the suited bonus in my strategy from five points to two, yet I had trusted the finished Python so completely that I skipped the most basic verification step before sending it to people whose entire course

revolves around coding poker math correctly.

The strategy was understood, but the code lost part of it

Codex did not fail because it misunderstood poker or because the instructions were too advanced. It understood the strategy well enough to modify one of its assumptions intelligently, then wrote software that failed to preserve a basic relationship between two of the rules.

The Python itself runs normally. The bug comes from the way the program represents the state of the hand. Several independent conditions were turned into one menu where only a single answer could exist, even though those conditions can overlap in reality.

A better implementation would keep those properties separate and apply every adjustment that is true. The coding required to fix it is not difficult. The difficult part is noticing that the implementation quietly changed the meaning of the strategy.

This is the part of AI coding that gets underestimated

A lot of predictions about programmers disappearing begin with the same demonstration. Someone describes an application, an AI agent writes hundreds of lines of code, the program runs, and the conclusion is that the programmer is no longer necessary.

That demonstration proves that implementation is becoming dramatically cheaper. It does not prove that generated software no longer needs someone who understands what the program is supposed to do.

The poker program looked finished. It parsed hands, handled player counts, calculated percentages, looped through the flop, turn, and river, and produced an answer without crashing. A quick functional check could easily have passed while the logic remained wrong.

That type of failure is more dangerous than broken syntax because nothing announces it. The software behaves normally while quietly encoding a rule that was never part of the original model.

Better AI can make human review easier to skip

Older coding models were easier to distrust because they often produced obvious mistakes. They forgot imports, invented APIs, wrote invalid syntax, or generated code that failed immediately. Modern agents increasingly produce code that looks like something a competent developer might submit for review.

That polish changes human behavior. I trusted this program enough to attach it to an email. I had not tested the program or read the implementation carefully before sending it.

The failure was therefore not only Codex making an implementation mistake. I also treated generated code as if generation had already included verification, because it was a simple code and written by AI.

That distinction is going to become increasingly relevant as coding agents improve. The stronger the output looks, the easier it becomes for people to stop checking it closely.

Testing helps, but somebody still has to know what to test

A regression test could catch this bug easily. The test would create a situation where top pair and no flush draw are both true, then verify that both adjustments are applied.

The harder part is realizing that such a test is necessary. If the agent already represented the postflop states as mutually exclusive, it could generate dozens of tests around the same assumption. Every menu option could pass, every percentage could be correct, and the program could still be wrong.

Tests verify the properties someone thought to test. They do not prove that nobody forgot a property.

That is where computer science remains larger than code generation. Someone still has to reason about state, relationships, assumptions, edge cases, and whether the software actually represents the system it was supposed to model.

AI changes the bottleneck

Coding agents are going to reduce the amount of routine implementation performed by humans. Boilerplate, repetitive integrations, migrations, basic tests, and familiar application structures are already becoming much faster to produce.

The work does not simply vanish. More of it moves into specification, architecture, review, debugging, security, testing, and understanding generated code well enough to know when something subtle is wrong.

That may actually make deep technical knowledge more valuable. When an agent can generate thousands of plausible lines quickly, the scarce skill becomes knowing which of those lines should exist and whether the assumptions underneath them are correct.

The future programmer may type far less code manually. That programmer may spend far more time reviewing software produced by machines.

The poker bug is small enough to make the point

This was not a complicated banking system or medical application. It was a tiny poker calculator with a simple postflop menu. The strategy allowed two conditions to exist at once, and the program allowed only one.

Codex understood the model well enough to improve the suited bonus from five points to two, yet still introduced that basic implementation error. Those two facts existed in the same coding session.

That is why the claim that AI can write code does not automatically lead to the conclusion that coding jobs or computer science disappear. AI can understand a specification, reason about it intelligently, and still produce software that needs human review.

The machines are becoming extremely good at implementation. Someone still has to read the code.