What Senior Leaders Get Wrong About Learning to Code in 2026

A senior leader asking "should I learn to code?" in 2026 is asking yesterday's question. Coding is the new spreadsheet. It is assumed, not differentiating. The question that separates relevant senior leaders from irrelevant ones is whether they can ship a working thing alongside AI, not whether they can write a function from scratch. The bar moved while most of us were still figuring out the old one.

I had this conversation last week. A senior individual, sharp, well-respected, exploring a move into a strategy role, sat across from me with a question that had clearly been bothering him for months. Should he learn Python? Should he take the coding bootcamp? Was that the door he had to walk through to stay relevant?

I told him no. Not because coding is useless. Because the question itself was the wrong one.

This essay is the long version of that answer. It is for senior leaders who feel the ground shifting under them, who suspect the rules have changed but cannot quite name how, and who are tired of being told to "learn AI" without anyone explaining what that actually means at their level. The short version is this. Stop asking whether you should learn to code. Start asking whether you can build something.

The story behind the wrong question

The person I was talking to has fifteen years of experience leading teams, owning P&L, sitting on steering committees, hiring talent. He is the kind of senior individual every organisation needs. Calm, thoughtful, has shipped real outcomes, knows how to read a room and move work through it.

And he was about to spend six months and a meaningful amount of money on a coding course.

When I asked him why, the answer was honest. He felt like everyone around him was suddenly technical. His twenty-something analysts were writing Python notebooks. His engineering peers were prototyping agents over the weekend. Even his CMO was talking about prompt engineering in a budget meeting. He felt left behind, and the fastest path he could see to feeling current was to learn the same languages they were speaking.

This is the trap. It is the senior-leader version of cargo-cult productivity. If everyone visible is typing into a terminal, the assumption is the value is in the typing. So you go learn the typing.

The value is not in the typing. The value is in the shipping.

Here is the part most leaders miss. Two years ago, the gap between thinking about a product and building one was an engineering team, a quarter of runway, and a roadmap meeting. Today, the gap is one focused afternoon and a Claude or Cursor session. AI did not lower the cost of coding by a little. It lowered it by an order of magnitude. The marginal cost of a working prototype now rounds to zero.

Which means the leaders who still believe their job is to "think about it" and then "hand it off" are signalling something they did not intend to signal. They are signalling that they have not understood the cost curve they are operating on. They are still acting like the old prices.

Meanwhile, their peers, the ones who get it, are showing up to meetings with running prototypes. Not slides describing prototypes. Actual working things that people can click and react to. That is the new senior move. The deck is the artefact of the old world. The prototype is the artefact of the new one.

I think about my own working week. Six months ago, when an executive asked me a question I had not seen before, my reflex was to schedule a follow-up, get a small team together, and come back with a structured answer in a week or two. Today my reflex is to open a working session with Claude or Cursor, sketch the question out as a small thing I can run, and bring the executive a draft answer the same afternoon. Not a polished answer. A directionally honest one. The conversations get sharper. The follow-ups get shorter. The trust compounds, because the room sees that the work is real, not performed.

That is what the senior leader who was sitting across from me was about to miss. The coding course would have taught him Python. It would not have taught him to think build-first. The two are different muscles. One is mechanical. The other is decisional. The decisional muscle is the one that actually changes a career in 2026.

The framework: build versus think

Three patterns separate senior leaders who stay relevant in 2026 from the ones who quietly age out. I keep coming back to them when I am asked the coding question.

1. Build-first thinking. The leader's first instinct on a new idea is "what is the smallest version of this I can stand up by Friday?" not "let me write a strategy memo." The strategy memo still exists. It comes after the prototype, not before it. The prototype is what forces the strategy to be honest. A working thing tells you in fifteen minutes what a memo would have hidden for six weeks. Senior leaders who develop this instinct ship faster than their teams expect and earn the kind of authority that titles cannot grant.

2. AI-as-collaborator literacy. This is not the same as knowing how to prompt a chatbot. It is the willingness to sit in a session with Claude, Cursor, ChatGPT, or whatever the tool is this quarter, and treat it as a peer reviewer, a co-builder, a junior engineer, a draft writer, and a sparring partner, often inside the same hour. Senior leaders who do this stop asking permission from their engineering teams to explore an idea. They explore it themselves, then bring the engineering team a working artefact and a real question, not a hand-wavy ask. The engineering team responds to the working artefact with respect that vague asks never produce.

3. Outcome ownership. The third pattern is the one that decides whether the other two compound. Senior leaders who ship now own the outcome of what they ship, not the activity of building it. They do not say "I built a thing." They say "I built a thing that answers a real question for a real customer." The build is a means. The outcome is the only thing the organisation actually cares about. Leaders who confuse the means with the ends end up with a portfolio of weekend prototypes that nobody uses, which is its own kind of senior-level theatre.

A simple way to picture the shift:

                Old senior playbook            New senior playbook
                ---------------------          --------------------
Day one         Strategy memo                  Working prototype
Day fifteen     Stakeholder review             Stakeholder reactions
Day thirty      Hire engineers                 Refine with engineers
Day sixty       First version ships            Third version ships
Day ninety      Steering committee asks        Customer outcome measured

Notice what happens in the right-hand column. The leader is closer to the work, closer to the customer, closer to the truth, every single week. The left-hand column inserts gatekeepers, translation steps, and waiting periods that today's tools have rendered optional. Optional, not impossible. Some organisations still demand the old playbook. Increasingly, the best leaders are quietly running the new one anyway and presenting the artefacts in the format the organisation expects.

A second observation. When you compress the loop, you also compress your own learning curve. Leaders who ship something every fortnight do not just produce more artefacts. They develop a faster instinct for what an idea will feel like once it is real. That instinct is the single most undervalued asset in senior work right now. It cannot be taught in a course. It can only be built by reps, the same way a senior surgeon's hands learn what a novice's hands cannot. The reps used to be expensive. They are no longer expensive. Leaders who treat the cheap reps as beneath them are voluntarily giving up the cheapest professional development the market has ever offered.

The deeper shift, and why coding is the wrong lever

Here is the part I did not get to in the conversation. The reason "should I learn to code" is the wrong question is that coding itself is shifting into the background. The action is moving up the stack.

Three years ago, the relevant skill was writing code. Two years ago, it was reviewing code that AI wrote. Today, the action is one level up again. It is choreographing a working system across tools, models, humans, and interfaces, in a way that produces a clear outcome.

This connects to a second shift I have been thinking about a lot. The interface itself is changing. The screen is no longer the only surface. Voice, gesture, attention, haptics, spatial computing, all of these are now valid inputs to the systems we are building. A senior leader who learns Python in 2026, and stops there, is preparing themselves to win the 2020 fight. They are studying the textbook for a test that has already been graded.

The leaders I see staying ahead are the ones investing time in three things at once. They are getting fluent with AI as a builder. They are learning to think across modalities, not just screens. And they are practising the muscle of shipping something small every week, even if it never sees the outside world, because that muscle is the one that compounds.

Coding shows up inside all of that. But it shows up the way driving shows up for someone whose job is logistics. Useful to know. Not the job.

There is a final reason this matters. Senior leaders who learn to code today, and then stop, often emerge from the course feeling more confident but no more useful. They can read a Python script. They cannot ship an outcome any faster than they could six months ago, because the bottleneck was never the code. It was the build-first instinct. The course did not address the instinct. It addressed a symptom. The leaders I see making the real leap in 2026 spent zero hours on coding lectures and many hours building tiny working things alongside AI. The artefacts are imperfect. The instinct is the asset.

Three things to do this week

1. Build one thing by Friday using AI as your collaborator. Pick a real question someone in your organisation is asking. Stand up the smallest possible answer to it. A working spreadsheet, a quick script, a Claude artifact, a clickable mock. Show it to the person on Friday. Watch what changes about the conversation when you arrive with a thing instead of a slide. Expect the second meeting to feel ten times more productive than the first.
2. Cancel one strategy memo this week and replace it with a prototype review. Pick a memo you were about to write. Replace it with a working artefact that demonstrates the same point. Send the artefact to the same audience. Note how the response differs from the response you would have got to the memo. Use the difference as input for what you build next.
3. Pair with AI for one full hour, uninterrupted, on something you would normally delegate. No email, no meetings, no Slack. One hour, you and an AI tool, working on a real problem you have been carrying. Treat the AI as a peer, not a search engine. The goal is not the output of the hour. The goal is the calibration of what you and the tool together can produce. Most senior leaders have not done this even once. The first one is the one that changes the calculus.

What to read next

While you are here, the back catalogue has more on the senior-leader reset:

• An Essay Every Week: What I'll Write About Here, and Why

Common Questions

[
  {
    "question": "What is the build-versus-think shift for senior leaders in 2026?",
    "answer": "The build-versus-think shift is the change in what senior leadership work looks like once AI has made the cost of a working prototype trivial. The old senior move was to think about a problem, write a memo, and hand it to a team. The new senior move is to stand up a small working artefact alongside AI, in hours not weeks, and use the artefact to force the strategy conversation to be specific. Leaders who only think now move slower than the cost curve allows."
  },
  {
    "question": "How does AI-as-collaborator literacy differ from knowing how to prompt a chatbot?",
    "answer": "Prompting a chatbot is a single-turn skill, asking a question and reading the answer. AI-as-collaborator literacy is the willingness to sit inside a long working session with an AI tool and treat it as a peer reviewer, a co-builder, a junior engineer, and a draft writer, often inside the same hour. The first is a query. The second is a working relationship. Senior leaders who develop the second stop needing permission to explore an idea, because they can prototype the idea themselves before involving anyone else."
  },
  {
    "question": "Why do senior leaders feel pressure to learn to code in 2026 when coding is no longer the bottleneck?",
    "answer": "Senior leaders feel that pressure because the visible activity around them has shifted, and they read the activity as the value. Their analysts type into terminals, their peers prototype on weekends, and the conclusion looks obvious. The conclusion is wrong. The value is not in the typing. The value is in the shipping. Coding has become low-cost background plumbing, like driving for someone in logistics. Useful, not the job. Leaders who confuse the two end up training themselves for last decade's role."
  },
  {
    "question": "When should a senior leader stop delegating prototypes and start building them personally?",
    "answer": "A senior leader should start building personally the first time they catch themselves writing a memo about a thing that could have been a prototype. The signal is simple. If the artefact you are about to produce is a document describing a future artefact, replace it with the future artefact. The cost is no longer a quarter of engineering runway. It is one focused afternoon with an AI tool. The right moment is not after a course or a certification. It is the next time the memo template opens on your laptop."
  },
  {
    "question": "What is the first step a senior leader can take this week to make the build-first shift?",
    "answer": "The first step is to pick one real question someone in the organisation is asking and stand up the smallest possible working answer to it by Friday. Not a slide. Not a memo. A clickable, runnable, viewable artefact. Use Claude, Cursor, or whichever tool fits the question. Show it to the person who asked the question. Watch the conversation change. The point of the exercise is not the artefact. It is the moment of realising that the gap between idea and demo is now hours, not quarters, and acting accordingly from that day on."
  }
]

Anees Merchant writes one essay every Tuesday about enterprise AI, agentic systems, and the human side of the work. He is the author of Merchants of AI, a TEDx speaker, and a doctoral researcher in Human-AI Communication at the Swiss School of Business and Management.

The newsletter version, with extra commentary, goes out separately on Mondays. Subscribe at /newsletter.

See you Tuesday.