Cognitive Courage: The Real Bottleneck to Learning AI Tools

Last month, on the R Weekly Highlights podcast, Eric Nantz was walking through Sharon Machlis’s 10 tips for getting better R code from your AI coding agent. He reached the tip about skills – the reusable instruction files you hand a coding agent so it knows how to tackle a recurring kind of task – and added an honest aside:

So I’ve been very much a consumer of skills. I still haven’t actually authored my own skill yet, but that is on my list this year.¹

I have enormous respect for Eric – few people have done more to teach this community – and I am picking on a single sentence said in passing, not on him. But that sentence captures a way of thinking about learning AI tools that I think is now exactly backwards. There is no skill to pencil in for “this year.” Authoring your first skill is one sentence to Claude away. What stands between most of us and that sentence is not time, and not expertise. It is courage.

I want to make that claim precisely, because it has a practical payoff: it should change how you spend your next hour with these tools.

Learning used to be a separate project

Think about how you picked up a genuinely new skill in the old world, which is to say eighteen months ago. Say you wanted to learn Shiny, the framework for building reactive web apps in R. You read “Mastering Shiny”, or opened the docs, and worked through them. You started a toy project on the side. You hit a wall, searched, landed on Stack Overflow, and when nothing fit you distilled the problem into a reproducible example and asked your own question. Eventually you got unstuck and went back to the toy project.

That loop is iterative, and it works. But notice two things about it. It is linear: you pick one skill and march along it, and the march is slow. And it is separate from the work: the learning is its own project, with its own clock, sitting beside whatever you were actually trying to ship. First the course, then the doing.

Now the workbench is the classroom

Working with a coding agent collapses that separation. The platform you do the work in is the platform you learn in, and the learning happens on top of the real task rather than beside it.

Here is the shape of it. You are in the middle of something real – cleaning a messy dataset, editing a podcast, wiring up a report. You notice you keep handing the agent the same instructions. You have read, somewhere, that skills exist. So you say: “turn what we just did into a skill.” That is the whole move. You are not sitting down to study skill authoring; you are delegating it, in context, while the example is still warm. The agent writes the skill, you read it, you change a line, and now you have one. You learned what a skill is by making one, inside work you were doing anyway.

This is why the cycles are so short. The old loop measured progress in weeks – a chapter here, a worked example there. The new one measures it in minutes, because every iteration hands you something you can use immediately and feedback you can act on right away. You are not learning in order to work. You are learning by working.

Why “on my list this year” is anachronistic

Back to Eric’s aside. The phrase “I still haven’t authored my own skill, but it’s on my list this year” belongs to the old model. It treats a skill as a body of knowledge you must acquire before you are allowed to use it, the way you might resolve to finally learn measure theory. So naturally it lands on a list, next to the other things you will get to when a free week appears.

But there is nothing to acquire first. Consuming a skill and authoring one are one gesture apart. Eric is, by his own description, already a fluent consumer of skills; the distance from there to his first authored skill is a single sentence to the agent at the end of a task he was doing anyway. It is not a project for next quarter. It is the next thing he says out loud. The to-do-list framing is not a personal oversight, it is the residue of a learning model the tools have quietly retired.

The bottleneck is courage, not capability

If the old barriers are gone, it is worth being exact about what they were, because naming them shows what is left.

You used to be blocked by not knowing how – the technique lived in a book you had not read. You were blocked by not having the information – the answer sat in a thread you had not found. And you were blocked by the cost of bridging – even with the technique in hand, fitting it into your specific project took real work. An agent now supplies all three on demand: the how, the information, and the integration into the very file in front of you.

Strip those away and one thing remains. You have to be willing to say, out loud, to a machine: I don’t know how to do this – show me. You have to start before you feel ready and let the not-knowing be the price of admission rather than a reason to wait. That readiness deserves a name, so I will call it cognitive courage: the willingness to enter a problem you cannot yet solve and learn it in the doing.

Cognitive courage is now the binding constraint on how fast you learn. Not your ability, not your access to information, not your skill at integration, all of which are suddenly abundant. The scarce input is the nerve to begin.

suppressPackageStartupMessages(library(tidyverse))

blue   <- "#2C7FB8"
gold   <- "#EDB458"
grey   <- "#5B6770"
fill_n <- "#D6EAF2"   # NOW boxes
fill_t <- "grey95"    # THEN boxes
ink_n  <- "#1b3b52"

hw <- 0.95; hh <- 0.42                # box half-width / half-height

# ---- THEN: a straight, linear track (y = 3.6) ------------------------
ty <- 3.6
tx <- c(1.4, 4.0, 6.6, 9.2)
then_rect <- tibble(xmin = tx - hw, xmax = tx + hw, ymin = ty - hh, ymax = ty + hh)
then_txt  <- tibble(
  x = tx, y = ty,
  label = c("Pick a\nskill", "Study\nbooks & docs",
            "Get stuck,\nsearch, ask", "Finally\napply")
)
then_arr <- tibble(x = tx[-4] + hw, xend = tx[-1] - hw, y = ty, yend = ty)

# ---- NOW: a loop you enter through a gate (y = 1.0) ------------------
ny <- 1.0
gx <- 1.1
nx <- c(3.7, 6.3, 8.9)                # Try, Ask, Learn
now_rect  <- tibble(xmin = nx - hw, xmax = nx + hw, ymin = ny - hh, ymax = ny + hh)
now_txt   <- tibble(x = nx, y = ny,
                    label = c("Try it in\nreal work", "Ask the\nagent", "Learn"))
gate_rect <- tibble(xmin = gx - hw, xmax = gx + hw, ymin = ny - hh, ymax = ny + hh)
gate_txt  <- tibble(x = gx, y = ny, label = "Cognitive\ncourage")

# forward arrows: gate -> Try -> Ask -> Learn
now_arr <- tibble(x = c(gx, nx[1], nx[2]) + hw,
                  xend = c(nx[1], nx[2], nx[3]) - hw, y = ny, yend = ny)
# return loop: Learn -> Try, arcing up and over the row
ret <- tibble(x = nx[3], y = ny + hh, xend = nx[1], yend = ny + hh)

ggplot() +
  annotate("text", x = 0.15, y = 4.62, hjust = 0, fontface = "bold",
           size = 4.1, colour = grey,
           label = "THEN  ·  learning was a separate project") +
  annotate("text", x = 0.15, y = 2.62, hjust = 0, fontface = "bold",
           size = 4.1, colour = blue,
           label = "NOW  ·  learning happens inside the work") +

  # THEN track
  geom_rect(data = then_rect,
            aes(xmin = xmin, xmax = xmax, ymin = ymin, ymax = ymax),
            fill = fill_t, colour = grey, linewidth = 0.5) +
  geom_segment(data = then_arr, aes(x = x, y = y, xend = xend, yend = yend),
               arrow = arrow(length = unit(0.16, "cm"), type = "closed"),
               linewidth = 0.5, colour = grey) +
  geom_text(data = then_txt, aes(x, y, label = label),
            fontface = "bold", size = 3.05, lineheight = 0.92, colour = grey) +
  annotate("text", x = 10.75, y = ty, hjust = 0, fontface = "italic",
           size = 3.1, colour = grey, label = "weeks") +

  # NOW return loop (behind the boxes)
  geom_curve(data = ret, aes(x = x, y = y, xend = xend, yend = yend),
             curvature = 0.24, ncp = 16, angle = 90,
             arrow = arrow(length = unit(0.16, "cm"), type = "closed"),
             linewidth = 0.55, colour = blue) +
  annotate("text", x = (nx[1] + nx[3]) / 2, y = 2.34, fontface = "italic",
           size = 3.1, colour = blue, label = "repeat in minutes") +

  # NOW gate, forward arrows, boxes
  geom_rect(data = gate_rect,
            aes(xmin = xmin, xmax = xmax, ymin = ymin, ymax = ymax),
            fill = gold, colour = "grey35", linewidth = 0.5) +
  geom_text(data = gate_txt, aes(x, y, label = label),
            fontface = "bold", size = 3.05, lineheight = 0.92, colour = "grey15") +
  geom_segment(data = now_arr, aes(x = x, y = y, xend = xend, yend = yend),
               arrow = arrow(length = unit(0.16, "cm"), type = "closed"),
               linewidth = 0.55, colour = blue) +
  geom_rect(data = now_rect,
            aes(xmin = xmin, xmax = xmax, ymin = ymin, ymax = ymax),
            fill = fill_n, colour = blue, linewidth = 0.6) +
  geom_text(data = now_txt, aes(x, y, label = label),
            fontface = "bold", size = 3.05, lineheight = 0.92, colour = ink_n) +

  coord_fixed(clip = "off", xlim = c(0, 11.7), ylim = c(0.4, 4.95)) +
  theme_void() -> p

ggsave(
  here::here("posts", "2026-07-27-cognitive-courage", "courage-loop.png"),
  p, width = 8, height = 3.2, dpi = 160, bg = "white"
)

p

Figure 1: Two ways to pick up a new technique. The old path is a long, linear march through study and search that runs beside the real work and resolves in weeks. The new one is a tight loop that is the work – try something, ask the agent, learn, repeat – and its entrance is guarded only by the willingness to begin before you know how.

Encourage, literally

There is a reason the English word is built the way it is. To encourage someone is, etymologically, to put courage into them: en- (to make) plus courage. If the bottleneck is courage, then the most useful thing we can do for each other, and for ourselves, is exactly that. Lower the cost of admitting you do not know. Treat “show me how” as the strong move it is, not the embarrassing one.

So here is a small call to action, mostly to my fellow data scientists. Embrace the gap between what you can do and what you would like to. Shorten the loop until learning and working are the same motion. The next time you catch yourself filing a tool under “things to learn this year,” stop, open the work you are already doing, and ask the agent to do it with you, now. As of now, the skill isn’t the obstacle. The courage to reach for it, in public, mid-task, before you are ready, is what makes the learning of this exciting new era.

In an earlier post I argued that data scientists are unusually well positioned for the AI era because the role already demanded the right mix of skills. This is the complimentary insight. The floor rose, the tools are sitting right there, and the only upgrade still required is in your willingness to reach.

Footnotes

1. Eric Nantz, R Weekly Highlights, episode 232 (issue 2026-W26), 26 June 2026, during the segment on AI coding tips (around 16:36). Episode page: https://serve.podhome.fm/episodepage/r-weekly-highlights/issue-2026-w26-highlights.