The Eleven Stages of a Programmer's AI Acceptance
A humorous (but uncomfortably accurate) field guide — updated for April 2026
Every programmer eventually goes on a journey. It starts with mild curiosity, passes through bargaining, and ends somewhere between awe and a credit card statement you'd rather not talk about. If you're somewhere along this path, take comfort: you are not alone, and you are definitely not early.
Stage 1: "ChatGPT? Isn't that just a chatbot?"
You read a Hacker News thread about something called "ChatGPT." A colleague mentions it in Slack. You nod knowingly, because that is what you do in Slack. You make a mental note to check it out this weekend, right after you finish that side project you started in 2019.
Symptoms: Mild curiosity. Casual dismissal. Tabs left open indefinitely.
Stage 2: "Okay, the rhyming poem is kind of impressive."
You finally type something into ChatGPT. You ask it to write a limerick about your cat. It does. It is funnier than anything you have written in a decade. You show it to your partner, who is polite about it.
You try a sonnet. You try a haiku about your build pipeline. You are, at this moment, a poet.
Symptoms: Giggling alone at the screen. Forwarding rhymes to people who did not ask.
Stage 3: "Wait — can it write code?"
This is the gateway drug.
You ask it for a regex. It works. You ask it for a Python function. It works. You ask it to explain a gnarly piece of legacy code your predecessor left behind, and it does a better job than your predecessor ever did.
You begin to suspect you might be on the verge of something. You also begin to copy-paste with the enthusiasm of someone who just discovered the microwave.
Symptoms: Increased productivity. Decreased Stack Overflow traffic. Vague sense of guilt.
Stage 4: "Hold on — it needs to see my repo?"
You try to get the AI to write unit tests. You paste one file. Then two. Then the AI politely points out that it would help if it could see the whole module. And the imports. And the types.
You realize, with a sinking feeling, that you are about to hand an AI access to your GitHub.
You do it anyway.
Symptoms: Reading OAuth scopes for the first time in your life. Briefly considering a career in farming.
Stage 5: "Oh. Oh. Claude Code."
Someone at a meetup mentions Claude Code. A command-line tool. "It's like ChatGPT," they say, "except it actually reads your codebase, finds the bug, and fixes it."
You install it. You point it at a bug you've been ignoring for three sprints. It fixes the bug in ninety seconds and then cheerfully offers to write tests for the fix.
You stare at the terminal. The terminal stares back.
Symptoms: Deleting your carefully curated VS Code extensions one by one. Speaking in reverent tones about "the agent."
Stage 6: "Skills. Skills are the answer."
You discover Claude Code Skills — reusable behaviors you can invoke by name. Every programmer secretly wants a personal assistant that does the boring parts of the job exactly the same way every time, and it turns out this is what a Skill is.
You realize your entire career has been an unstructured pile of ad-hoc shell scripts, and this thing — this humble Skill — is the structure you have been missing since 2007.
Symptoms: Suddenly caring about YAML frontmatter. Explaining the word "idempotent" at parties.
Stage 7: "I shall make my first Skill."
You invoke the skill-creator skill to create a skill. There is something deeply satisfying about this, like a compiler compiling itself.
Your first Skill is modest. Maybe it just formats a commit message the way you like. Maybe it just renames files. You do not care. You made it. It is yours.
You name it something embarrassing. You do not change the name.
Symptoms: Adding ~/.claude/skills to your dotfiles repo. Telling your spouse about it at dinner. They nod politely. (See Stage 2.)
Stage 8: "Why is anything NOT a Skill?"
A fever takes hold.
Standup notes? Skill. PR descriptions? Skill. The weird, specific way you like to name branches? Skill. Generating a changelog? Skill. Explaining legacy code to your future self? Skill.
Your ~/.claude/skills directory now has more files than your actual project. You have a Skill that writes Skills. You are pretty sure you had a second breakfast today but you can't remember because you were too busy creating a Skill to log breakfasts.
Symptoms: Everything is a nail. The hammer is very, very shiny.
Stage 9: "What do you mean, 'usage limit'?"
It happens on a Tuesday. You are mid-flow, deep in the zone, and the terminal politely tells you that you have reached your message limit.
You stare. You blink. You refresh. You try a different prompt. You google "Claude usage limits" with the desperation of a caffeine addict at a decaf-only conference.
You upgrade to the Claude Code Max plan before the page finishes loading.
Symptoms: A recurring monthly charge you do not regret. A quiet conversation with yourself about the nature of value.
Stage 10: "Wait — they shipped what?"
You open the changelog. There are new features. You had not heard about them. You read the changelog more carefully. There are features on top of those features.
You realize Anthropic is shipping faster than you can read release notes. You discover that Claude Code Desktop has added three things this week that would have each been a full product at any other company. Someone mentions "Mythos" and you pretend to know what that is.
You accept, at last, that the exponential curve is not something you observe — it is something you are inside of.
Symptoms: Bookmarking the changelog. Checking it more often than email. An uneasy respect for the word "compound."
Stage 11: "Maybe I should finally read Kurzweil."
You crack open The Singularity Is Near. You meant to read it years ago. You assumed it was science fiction.
It reads like a current events book.
You close it gently. You look out the window. You consider your career, your Skills, your Max plan, and the nine tabs of Anthropic documentation you have open. You feel a strange mixture of awe, hope, mild existential vertigo, and a sudden urge to create one more Skill.
Symptoms: Clarity. Acceptance. A deep and abiding curiosity about what Stage 12 will look like.
Epilogue: What Stage Are You?
If you recognized yourself somewhere between Stage 4 and Stage 7, you are in good company — that is where most developers are right now. If you're at Stage 9, welcome to the club; the pastries are metaphorical but the productivity is real. If you're at Stage 11, congratulations: you have arrived at the beginning.
The journey doesn't end here. It probably doesn't end at all. The curve keeps going, and so do we — one Skill, one commit, one quietly terrifying changelog at a time.
See you at Stage 12.