Getting good at AI takes time and practice
Sean Goedecke argues that using AI well is a real, durable skill, not something you can pick up instantly once models improve. He lists the parts of that skill, from supplying context to reviewing AI-written code, and says engineers who avoid AI entirely are falling behind.
- Good AI users supply context and explain the reasons behind a goal, because agents guess badly when they're missing information.
- Knowing what models can and can't do is durable: new models improve most on tasks older ones already handled well, so that sense carries over.
- AI-generated code looks polished but makes different mistakes than humans do, such as adding unnecessary mutexes for trivial edge cases, so reviewers need a separate skill set.
- Avoiding AI completely means being left behind, though the author warns against going all-in, since LLMs reward expertise that comes from doing the work by hand.
Getting good at AI, according to Sean Goedecke, takes real practice, and the popular idea that you can just tell the model what you want and skip any learning curve doesn't hold up. He names three areas where skill shows up. The first is supplying context. Newcomers often ask an agent to "solve my issue" without saying what the issue is, or ask about Slack without connecting it. Experienced users state the goal and the reason behind it, because the agent will otherwise guess and guess wrong. The second is knowing what the model can and can't do. Capabilities are uneven and hard to predict: Goedecke will ask an agent for new architectural ideas but not for new product features, and he notes that PR descriptions are a task models are bad at until prompted properly. He also points out that he struggled to set up MCP servers in GitHub Copilot until he realized he could just ask Copilot to install them, and that he only recently started scheduling an overnight agent job to triage messages from other timezones. The third is knowing where models go wrong. Reviewing AI code is a different job from reviewing human code. Models rarely make off-by-one errors but often add mutexes for trivial edge cases, and the polished comments and tests can make reviewers trust the code too quickly. He also lists the skill of skimming verbose AI output quickly to find the actual claims.
Goedecke argues these skills are fairly durable. New models tend to improve most on tasks older models already handled well, so a sense of their limits carries forward. He compares the current period to chess's "centaur age," when human-machine teams beat either alone, and says that could last decades, much as learning React was worthwhile even though frameworks come and go. He also lists further skills he leaves out, including when to steer or abandon an agent session, how to split work between agents, when to verify claims, and how to cut costs with smaller models. His analogy is managing a brilliant but erratic employee with no long-term memory, someone who needs time before you know how to get value from them.
His practical conclusion is that avoiding AI entirely leaves you behind, and advising others to do so does them no favors. He still warns against going all-in, since LLMs reward expertise, and he thinks that expertise is best built by hand first. The upshot is that regular, hands-on practice is the only way to get good at this, and skipping it means you never will.