DEV Community

Cover image for An AI subscription won't make you senior (here's what will)
JavaScript Mastery
JavaScript Mastery

Posted on

An AI subscription won't make you senior (here's what will)

You can buy the best model on the market for the price of a few lunches a month. So can the person sitting next to you, and so can every junior dev who applied for the same job as you.

That's the uncomfortable part. When everyone has the same model, the model stops being your edge. What's left is the part you can't subscribe to: knowing when the code it gave you is wrong, and catching it before your users do.

This post is for devs who already use AI every day and want to get better at the part that still depends on them. By the end you'll have five habits and a short review checklist you can use on your next pull request.

Same model, different results

Give two developers the same model and the same ticket. One ships a clean fix in an hour. The other ships something that passes review, breaks for a slice of users a week later, and costs a day of debugging.

The model didn't change between them. What changed:

  • how clearly the task was described before anyone hit enter
  • how big the change was (one you can read in a sitting, or 900 lines)
  • whether anyone actually checked the output, or just skimmed it
  • whether the person knew which parts of the code were risky

None of that comes with a paid plan. It's the same stuff that made someone senior before AI showed up. Senior was never about typing speed. It was about scope, risk and knowing what to check.

Here's what "looks fine" looks like

A small example. You ask an agent for a helper that tells you if an event is happening today. It gives you this:

function isToday(dateString, now = new Date()) {
  const d = new Date(dateString); // e.g. "2026-11-22"
  return (
    d.getDate() === now.getDate() &&
    d.getMonth() === now.getMonth() &&
    d.getFullYear() === now.getFullYear()
  );
}
Enter fullscreen mode Exit fullscreen mode

It reads well. It passes a quick test on your machine. You merge it.

Then someone in New York opens the app and their event for today shows up as yesterday's.

The reason: a date-only string like "2026-11-22" is parsed as midnight UTC, not midnight local time (MDN: Date.parse()). getDate() then reads that moment in the user's local time zone. Anywhere behind UTC, midnight UTC is still the previous evening.

We ran it with the same "now" (Nov 22, 10:00 local) in three time zones:

Time zone isToday("2026-11-22")
Asia/Dhaka true
Europe/London true
America/New_York false ❌

If your laptop is in Dhaka or London, you will never see this bug. That's why it gets merged.

The fix is boring, which is a good sign:

function isToday(dateString, now = new Date()) {
  const [y, m, d] = dateString.split("-").map(Number);
  return (
    y === now.getFullYear() &&
    m === now.getMonth() + 1 &&
    d === now.getDate()
  );
}
Enter fullscreen mode Exit fullscreen mode

No parsing, no time zone conversion. Just compare the parts.

The model that wrote the first version isn't "bad". This bug has been in human-written code for years, and that's exactly why it shows up in generated code too. Your job is knowing that date parsing is a place where bugs hide, and testing it like one.

5 habits that make the judgment part repeatable

1. Write the plan before you write the prompt

Before you ask for code, write down what "done" means and what must not change. Two or three lines is enough:

Goal: show "Today" badge on events happening today (user's local date).
Don't touch: the events API, existing date formatting.
Done when: tests pass in UTC-5, UTC and UTC+6.
Enter fullscreen mode Exit fullscreen mode

That last line alone would have caught the bug above. A plan also makes the agent's output easier to review, because you know what you're checking it against.

2. Keep each task small enough to review in one sitting

If the diff is too big to read properly, you won't read it properly. You'll skim, see that it looks reasonable, and approve.

Split the work so each change is something you can actually hold in your head: one helper, one component, one migration. More prompts, but far fewer surprises.

3. Read the diff like a stranger wrote it

Because one did. Don't ask "does this look right?" Ask "where would this break?"

Some places worth a second look every time:

  • dates, time zones and currency math
  • anything with async inside a loop
  • error handling (what happens when the API returns a 500?)
  • auth checks and anything that touches user data
  • code that "handles" an edge case by ignoring it

4. Make the agent prove it

"It works" is a claim. A failing test that now passes is proof.

Ask for the test first, run it, watch it fail, then ask for the fix. For the date helper, the test that matters is the one that runs in a time zone behind UTC:

// run with: TZ=America/New_York node --test
import { test } from "node:test";
import assert from "node:assert/strict";
import { isToday } from "./isToday.js";

test("date-only string matches the local day", () => {
  const now = new Date(2026, 10, 22, 10, 0); // Nov 22, 10:00 local
  assert.equal(isToday("2026-11-22", now), true);
});
Enter fullscreen mode Exit fullscreen mode

The first version fails this test. The fixed one passes.

5. Write down what the agent got wrong

Every time you catch a mistake, add one line to the rules file your agent reads (AGENTS.md, CLAUDE.md, .cursor/rules, whatever your tool uses):

- Never pass date-only strings ("YYYY-MM-DD") to new Date(). Compare the parts instead.
Enter fullscreen mode Exit fullscreen mode

Next month you'll probably be on a different model. Your rules file comes with you. This is the part people skip, and it's the part that compounds.

A 2-minute review checklist

Copy this into your PR template if you like:

  • [ ] I can explain what every changed line does
  • [ ] I know what happens when the slowest or flakiest call fails
  • [ ] Dates, money and time zones were tested, not eyeballed
  • [ ] There's a test that would have failed before this change
  • [ ] Nothing outside the task's scope was touched
  • [ ] Anything the agent got wrong is now in the rules file

What this doesn't fix

Habits won't replace knowing the fundamentals. You can't spot a time zone bug if you don't know dates have time zones. You can't question a database query if you don't know what an index is. The more you know, the more of the agent's output you can actually judge.

And none of this means "use AI less". Use it as much as you want. Just stay the one who decides what gets merged.

The model will keep changing every few weeks. The judgment is what you keep.


P.S. Black Friday: from Thu Nov 26, the Agentic Engineering course is 25% off. It teaches the workflow that makes the judgment part repeatable: Agentic Engineering course

Top comments (0)