Should You Still Become a Software Engineer in 2026? GitHub VP

Jean Lee (interviewer); Scott Hanselman (guest, VP & Member of Technical Staff, Microsoft/GitHub) · video · 2026-06-25 source ↗ Reader 🖥️

practical · mixed — An interview that mixes narrative (Hanselman's personal history and live tool demos) with argument (accountability, apprenticeship-collapse, career advice), all in service of practical conclusions: what an aspiring engineer should do, and what organizations should do about junior hiring.

Structure

Key terms

• slop cannon vs. AI-augmented software engineering
  The two poles of a spectrum for how AI-generated code enters a codebase: 'slop cannon' is uncritical, sycophancy-driven AI output flooding in unreviewed ('vibes'); 'AI-augmented' is AI-assisted authorship that still passes through the same rigorous SDLC (signing, testing, CI, review) as any other code source.
• same ingress point
  The principle that code should be verified identically regardless of where it came from — his own hands, an anonymous open-source PR, or an AI — because the SDLC gate, not the source's identity, is what makes code trustworthy.
• preceptor (nurse preceptor model)
  A named, formally credentialed senior role ('nurse trainer, nurse preceptor') that a newcomer can safely approach with basic questions without status penalty — proposed as a replacement for the 'intern/apprentice' framing in software engineering, where the senior's job is explicitly to make more seniors.
• T-shaped
  Specializing deeply in one area while maintaining broad competence ('Swiss Army knife') across the rest of the stack — his answer to 'generalist or specialist?'
• Tiny Tool Town
  His personal catalog site (500+ tools) for small, single-audience 'dumb' tools, where the entire application datastore is literally GitHub issues and the site is fully static (Astro-generated, no database, no realtime layer) — his working example that most engineers reach for infrastructure they don't need.

Propositions

• explicitEach new developer productivity tool (hand-assembly to high-level languages, syntax highlighting, autocomplete, Stack Overflow, now AI) has triggered the same 'this is the death of real programming' panic, and the craft has survived each one unchanged.conf: high
  supportsArvind Narayanan on Why AI Isn't All That Revolutionary · p10 — Both name the same recurring pattern — each generation's AI/tool capability is judged uniquely dangerous or civilization-ending in the moment, then normalizes and looks trivial in hindsight — Hanselman's four-decades-of-panic anecdote is a first-person instance of Narayanan's general claim.
• explicitRoughly 70% of the code Hanselman personally writes today is AI-augmented, but it is safe only because it flows through the same software development lifecycle (code signing, testing, GitHub Actions, Dependabot, agentic review) as code from any other source.conf: high
  extendsA model that produces code which compiles and passes the tests it was given is not the same as a model that produces robust code · p3 — Converges with Marcus's caution against celebrating raw AI-authorship percentages — Hanselman's 70% figure is safe only because it flows through an unchanged verification pipeline, not because of the number itself.
• explicitestablishedBecause AI cannot be held accountable, the human who reviews and merges bears full responsibility for what ships — exactly as if an anonymous human contributor's pull request had caused the same harm.conf: high
  supportsA cautionary tale about AI in tech writing: Why "Trust but Verify" is the only way to scale · p11 — Both locate final accountability irreducibly with the human regardless of how mechanically the work was produced, independently converging on the same 'trust but verify' principle.
  supportsAddy Osmani’s Post · p6 — Both reject 'the AI did it' as a defense when shipped code causes harm.
  supports ←Coding agents have crossed a chasm · p3 — Both land on the same accountability rule: the human who reviews and merges a change is responsible for it regardless of whether a human or an agent authored the code.
  supports ←SWLW #711: The laws of this world (game theory), Should you still become a Software Engineer in 2026, and more. · p1 — Same Hanselman claim (AI cannot be held accountable, so the human reviewer bears full responsibility exactly as with an anonymous PR) restated at digest length; the full extraction carries the complete argument and context.
• explicitThe software engineering profession will collapse if organizations stop hiring and training early-career developers, because senior engineers have no source other than a training pipeline — poaching trained seniors from competitors does not scale industry-wide.conf: high
  extendsEngineering Leadership Report 2026 · p12 — Supplies the causal mechanism (no future seniors without trained juniors) behind Postman's finding that 84% of leaders see AI harming junior entry while only 4% act on it.
• explicitcorroboratedLabeling new hires 'interns' or 'apprentices' creates a status/power asymmetry that discourages basic questions; a named 'preceptor' role (borrowed from nursing) that makes senior engineers formally responsible and measurable for how many new seniors they mint is a better institutional design.conf: high
  supportsHow to Turn Individual Talent into Organizational Excellence · p3 — Both independently converge on senior-as-systematic-teacher (deliberately engineered, not personality-dependent) as the mechanism for talent development.
  extends ←Podcast: How Will We Train Developers If AI Does the Routine Work: A Conversation with Scott Hanselman · p2 — Same preceptor proposal, elaborated here with the full nursing analogy, explicit evaluation criteria, and a completed-first-cohort pilot report.
  supports ←What's an Orchestrator—and Why Does Software Need One? · p18 — Both propose formal, named apprenticeship/preceptor structures (nursing-style preceptor / doctors-and-lawyers-style apprenticeship) as the mechanism for training people into AI-era engineering responsibility, since bootcamps/certificates don't do it.
• explicitDeep understanding of fundamentals (HTTP, DNS, distributed systems, deadlocks) matters more, not less, in the AI era, because someone still has to 'change the tire' when the automated abstraction breaks down.conf: high
  supportsDet skal være vanskelig · p3 — Both invoke Bainbridge's ironies-of-automation logic: the more capable the tool, the more critical (and more atrophy-prone) the human's residual understanding.
• explicitCommunicating intent clearly is as core a professional skill as writing code, because programming is fundamentally 'expressing intent clearly' — engineers who thrash through many unproductive AI turns are usually failing at clarity, not at technical ability.conf: high
• explicitA hiring portfolio's value comes from personal specificity and demonstrated agency (a project you genuinely care about), not from technically impressive but generic AI-generated clones of well-known software.conf: high
• explicitA single well-known proper noun in a prompt (e.g. 'Minecraft') carries an enormous amount of implicit specification, invisible to the person using it until the noun is forbidden and the true scope of the ask is revealed.conf: medium
• explicitcorroboratedAI does not generate software architecture; left unchecked it produces 'god objects' — large, messy, feature-shaped output — so architectural judgment remains an irreducibly human responsibility.conf: high
  supports ←Podcast: How Will We Train Developers If AI Does the Routine Work: A Conversation with Scott Hanselman · p1 — Same claim (AI generates features well but is architecturally myopic, producing 'god objects') corroborated with a fresh, concurrent anecdote from Hanselman's own current project, in a different venue.
• explicitcorroboratedMost engineers reach for databases and real-time infrastructure they don't actually need; simple, static, cache-in-memory architectures (GitHub issues as the entire datastore, a 300MB in-memory XML blog after 22 years) are usually sufficient and far more maintainable.conf: high
  supports ←Paweł Huryn's Post · p6 — Both argue engineers habitually reach for database/infrastructure complexity they don't actually need, when simpler file-based or in-memory approaches suffice.
• explicitRoughly three concurrent AI-agent sessions is the practical ceiling for effective human supervision (more than that is unreasonable), though a single long-running session can be parked and returned to hours later without counting against that limit.conf: medium
• explicitOrganizing a large personal backlog (125 to-dos, 111 PRs) around emotional/energy state rather than a flat priority queue makes the backlog navigable and produces the subjective feeling of being supported rather than surveilled.conf: medium
• implicitThe interview's own organizing question — 'should you still become a software engineer' — presupposes a stable, code-writing-centered definition of the profession; Hanselman's actual answer quietly redefines the job around fundamentals, communication, and judgment, largely independent of who or what writes the code.conf: medium

Arguments

Narratives

• Hanselman's personal 42-year history of being told his craft was ending — not a 'real programmer' without assembler (1989), 'brain rot' from syntax highlighting (late '90s), 'death of coding' from Stack Overflow copy-paste (mid-2000s).
  → Shows, rather than argues, that the current AI panic is structurally identical to prior tool-adoption panics — grounds proposition p1.
• The 'emoji bake' PR: a 2,000-line-diff contribution that first looked alarmingly large, but on inspection was a legitimate encoding-bug fix with 100 lines of new tests, which Hanselman reads carefully before running 'adversarial reviews with three or more models.'
  → Demonstrates what disciplined trust-but-verify review actually looks like in his own GitHub Copilot app workflow — supports p3 and p10.
• The nurse-preceptor analogy, drawn from his wife (a nurse) and son (training to be one): a preceptor's name tag signals 'safe person, ask me anything,' contrasted with the fear a junior engineer feels asking a senior engineer what DNS stands for.
  → Grounds the abstract preceptorship proposal in a concrete, working institutional model from another profession — supports p5.
• A young person told Hanselman he 'one-shotted' a Minecraft clone; when challenged to redo it without using the word 'Minecraft,' he couldn't, and the required prompt exploded in length.
  → Illustrates how much implicit specification a familiar proper noun smuggles into a prompt, and why a generic AI-generated clone demonstrates little — supports p8 and p9.
• Tiny Tool Town (500+ community-submitted tools, backed entirely by GitHub issues, statically generated with Astro) and his 22-year blog (300MB of in-memory XML, invalidated only on new posts) — both managed day-to-day by his own agents doing triage and maintenance checks.
  → Concrete demonstration that simple, static, disposable architectures usually suffice, undercutting reflexive reach for databases/real-time infrastructure — supports p11.
• 'Hansel Projects Today' — his personal AI-built dashboard that triages 125 to-dos and 111 PRs by emotional/energy state, informed by his own Type 1 diabetes and blood-sugar variability, distinguishing human PRs from bot PRs.
  → Shows AI used to make its author 'a better human' rather than just a faster one — supports p13.

Questions addressed

• ✅ Should you still become a software engineer, given AI coding agents?
  Yes — if you build strong fundamentals, communicate intent clearly, and build something personally meaningful rather than a generic AI-generated clone.
• ✅ How does the current AI-driven shift in software engineering compare to previous major tool shifts (web, mobile, cloud)?
  It's the latest instance of a recurring pattern of tool-driven panic; the underlying craft has not changed across any of the prior shifts and Hanselman expects the same here.
• ✅ What share of a senior practitioner's real day-to-day workflow is AI-assisted, and how is it kept safe?
  About 70% of his own code, kept safe by routing all code — human, open-source, or AI — through the same unchanged SDLC (signing, testing, CI, agentic review).
• ⭕ How does the industry preserve or rebuild the junior-to-senior training pipeline once AI absorbs junior-level tasks?
  Hanselman names the collapse risk and describes an emerging, unvalidated Microsoft preceptorship pilot (with Microsoft Research exploring 'teaching models' for juniors) as a partial response, but does not resolve the cross-company free-rider dynamic he himself raises.
• ⭕ Is Hanselman's own extremely high-agency, tool-building practice (building his own agentic triage system, running 100+ PRs across a personal portfolio, VP-level access to GitHub's own AI tooling) representative of what an average practicing engineer can achieve, or contingent on his unique seniority and resourcing?

Gaps

• incompleteHanselman names the junior-training collapse as an industry-existential risk but the only concrete remedy offered — Microsoft's internal preceptorship pilot — is single-company, unvalidated, and does not address the free-rider dynamic he himself names: a firm that trains juniors well risks losing them to competitors that don't train at all. No mechanism is given for why individual-firm preceptorship programs don't just subsidize poachers.
  Read next: Look for industry-level (not single-firm) proposals for the apprenticeship collective-action problem, or follow-up reporting on whether Microsoft's preceptorship pilot produces measurable retention/promotion outcomes.
  closed byPodcast: How Will We Train Developers If AI Does the Routine Work: A Conversation with Scott Hanselman — That gap notes no mechanism was given for why individual-firm preceptorship doesn't just subsidize poachers. Here Hanselman partially addresses it: poached seniors 'use their competitor's techniques and their competitor's culture,' giving firms a private-benefit reason to grow their own people rather than rely on poaching -- though this argues training is still worthwhile despite leakage, not that the free-rider/collective-action problem itself is solved.
• uninformedThe '~70% AI-augmented' and 'three sessions is optimal' figures are self-reported, uninstrumented estimates from a single high-context practitioner (a VP with deep, privileged access to GitHub's own Copilot tooling and the authority to insist on rigorous SDLC infrastructure) rather than measured or benchmarked data, and may not generalize to engineers with less resourcing or organizational authority.
  Read next: Compare against this corpus's instrumented AI-impact measurement sources (e.g. DX/Pragmatic Engineer throughput studies) rather than taking a single practitioner's self-report as representative.
• illogicalThe 'know the basics because the automation will break' argument (Waymo/stick-shift analogy) is asserted as self-evidently true, but is never reconciled with his own opening anecdote mocking the 1989 claim that 'you're not a real programmer without assembler' as mere panic — he doesn't say which fundamentals are actually load-bearing today versus which are the modern equivalent of the assembler gatekeeping he dismisses.
  Read next: extract-det-skal-vaere-vanskelig or other ironies-of-automation sources for a more rigorous account of which specific skills survive automation versus which atrophy safely.

Closes gaps elsewhere

• Engineering Leadership Report 2026 · g6 — Provides a named organization (Microsoft/GitHub) explicitly beginning to act on the junior-training gap via a formal preceptorship pilot — a partial answer to the report's unanswered call for 'any organization that is addressing it,' though outcomes remain unvalidated.
• SMOC.AI's Post — 5 Minutter: AI og utviklere · g1 — Proposes a concrete institutional mechanism — nursing-style preceptorship, plus Microsoft Research work on 'teaching models' (pause-to-explain, quizzes) for junior-AI interaction — as a partial answer to what replaces the vanishing on-ramp, though not yet validated at scale.
• Itchy Brain (Still Burning: Michael Grinich & Kent Beck on AI adoption, enterprise developer tools) · g3 — Names a concrete transition mechanism (preceptor role, senior measured by seniors minted) for the apprenticeship transition that the prior episode left unanswered, though the cross-company free-rider problem remains unresolved.

Related documents

• A model that produces code which compiles and passes the tests it was given is not the same as a model that produces robust code
• Det skal være vanskelig
• How to Turn Individual Talent into Organizational Excellence
• Addy Osmani’s Post
• Can an AI-Powered Scribe Curb Physician Burnout?
  Human-in-the-Loop Systemic Apprenticeship & Skill Transmission Trust
• Andrew Kelley Interview: Why He Built Zig, Banned AI Contributions, and Moved Zig off GitHub
  AI Slop Systemic Apprenticeship & Skill Transmission Trust
• Software Design in the Agentic Age: Place Your Bets
  Human-in-the-Loop Ironies of Automation Malleable Software
• Agentic Code Review
  Human-in-the-Loop Measuring AI Impact
• Agentic Skill Decay
  Skill–Ability Gap Systemic Apprenticeship & Skill Transmission
• Your AI agent just blamed the network team. Now what?
  Human-in-the-Loop Trust