World Model Readiness
Engraved role-check instrument

For you

Role Checks

Module · Senior at the wheel, or passenger

The Developer's AI Check

Coding AI can make you dramatically faster or quietly make you worse, and the difference is entirely in how you use it. A senior developer treats generated code as a draft from a fast, confident junior: reviewed, understood, tested, owned. A passenger accepts it because it compiles. This module checks whether you review your own AI output honestly, understand what you ship, catch the security and test gaps it leaves, and keep the fundamentals sharp underneath.

Question 1 of 5 · You review AI code

Do you review AI-generated code as hard as you would a colleague's?

Generated code reads well and feels authoritative, which is exactly why it slips through. The bar that keeps you safe is simple: review it as if a stranger wrote it and you have to sign off, because you do.

Question 2 of 5 · You understand what you ship

Can you explain every line of AI code you commit?

Shipping code you cannot explain is borrowing against a debt that comes due at the worst moment: the outage, the audit, the change request. Understanding is the difference between using the tool and being used by it.

Question 3 of 5 · You catch security holes

Do you check AI-generated code for security flaws it quietly introduces?

Models reproduce the insecure patterns they were trained on: injection, weak crypto, leaked secrets, missing checks. The code works in the demo and fails in the breach, and the tool will not warn you which is which.

Question 4 of 5 · You test AI code

Do you hold AI-written code to the same testing bar as your own?

It is tempting to trust generated code because it looks complete, but looking complete is not the same as being covered. Tests are how you find the gap between what the model claimed and what the code actually does.

Question 5 of 5 · Your fundamentals stay sharp

Are you keeping the underlying skills the AI is doing for you?

Skills you stop using fade, and the tool is happy to do the exact work that once kept yours sharp. If you cannot still solve the problem without the AI, you are not directing it, you are depending on it.

For the statistics · one click each

Three questions for the public picture

These do not affect your score. They feed the anonymised, aggregated statistics; groups under 8 respondents are never shown.

How do you handle AI-generated code before it ships?

Merge as is
Quick skim
Read fully
Line-by-line review
I use none

How much of the AI code you commit do you fully understand?

Very little
Some of it
Most of it
All of it
Hard to say

Since using coding AI, where are your core skills heading?

Getting rustier
Holding steady
Mixed
Still growing
Not sure

Your context

Used to calibrate the report. Company size and sector remain in the anonymized dataset; your email does not.

What the five levels look like

Every dimension in this assessment is scored 1 to 5. This is what the levels mean, dimension by dimension. The graded report diagnoses where your own answers land and what to do about it.

You review AI code

  1. 1Merge on sight
  2. 2Skim and ship
  3. 3Read it through
  4. 4Review line by line
  5. 5Review like a stranger's

At the low end: Merging generated code on sight means the model is the last set of eyes on your work. Read every line before it ships and hold it to the standard you would demand in any review. What good looks like: Reviewing generated code like a stranger's is exactly the senior habit. Keep it up even when the tool is usually right; the one time you wave it through is the one that bites.

You understand what you ship

  1. 1Rarely
  2. 2Mostly guessing
  3. 3The gist
  4. 4Nearly all
  5. 5Every line

At the low end: Committing code you cannot explain guarantees you cannot debug it later. Before you merge, work through anything you do not understand until you could defend it in a review. What good looks like: Being able to explain every line is what keeps you the engineer, not the tool. Hold that bar as the volume of generated code grows; it gets tempting to let more through unread.

You catch security holes

  1. 1Never look
  2. 2Assume it is safe
  3. 3Occasional check
  4. 4Deliberate review
  5. 5Threat-model it

At the low end: Never checking generated code for security is how vulnerabilities get shipped with confidence. Learn the common flaw classes and scan every generated block against them before it merges. What good looks like: Threat-modelling generated code is exactly the discipline the tools require. Keep your knowledge of the flaw classes current; the patterns evolve, and so do the ones the model reproduces.

You test AI code

  1. 1No tests added
  2. 2Trust it works
  3. 3Light tests
  4. 4Full coverage
  5. 5Tests before merge

At the low end: Shipping untested generated code trusts a tool that cannot run your system. Write tests for it exactly as you would for hand-written code, especially around the edges the model tends to miss. What good looks like: Holding generated code to a full testing bar before merge is the senior standard. Keep it non-negotiable; the pressure to skip tests rises exactly as the tool makes writing code feel free.

Your fundamentals stay sharp

  1. 1Skills rusting
  2. 2Coasting on AI
  3. 3Some practice
  4. 4Deliberate practice
  5. 5Sharper than ever

At the low end: Letting your fundamentals rust makes you unable to catch the tool when it is wrong. Set aside regular time to solve real problems yourself, without the AI, and keep the core skills alive. What good looks like: Keeping your skills sharp while the tool does the grind is what makes you dangerous in the best way. Maintain the practice; the developers who let the fundamentals go will not notice until it is too late.