Howardism

Question#

What are the opinions of using AI tools, and what are the futures of the software engineering role?

TL;DR#

The sources in this wiki cluster into four distinct stances on using AI tools — bullish-insider, pragmatist-practitioner, skeptic-governance, and architecture-thesis — and they largely agree on the direction of the SWE role even while disagreeing on pace and risk: coding skill becomes the baseline, the differentiator moves to deciding what to build, designing the agent's environment, and verifying output. Domain knowledge and human judgement appreciate; raw coding throughput depreciates. The honest caveats: most of this evidence comes from inside Anthropic plus one independent practitioner, the strongest predictions ("100 lines of code") are self-described hyperbole, and the one rigorous empirical study in the set (HBR / Kropp et al.) is a warning, not an endorsement.

Part 1 — Opinions on using AI tools (four stances)#

Stance A — Bullish insider: "coding is solved, the harness shrinks, loops are the future"#

Primary voices: Boris Cherny (creator of Claude Code), Cat Wu (Head of Product, Claude Code & Cowork).

"Coding is solved (for me)." Boris writes 100% of his code via Claude Code, has logged 150-PR days, works phone-first running hundreds of agents by day and thousands overnight (Boris Cherny). Explicit caveat: not yet true for very large codebases or off-distribution languages.
The harness should shrink, not grow. Harness Shrinkage as Models Improve: every model release lets the team delete prompt sections; Boris predicts Claude Code "may be 100 lines of code a year from now" (he frames this as hyperbole-with-a-real-direction). Cat Wu's discipline: read the entire system prompt at every launch and subtract anything the new model handles natively.
Capabilities migrate inward. The /loop primitive (see Agent Loop Pattern) went from harness feature to model-native behavior in Opus 4.7 — "I noticed the data is changing, I'll start a loop and report every 30 minutes." Boris: "Loops are the future at this point."
Build for the next model, not this one. Anthropic shipped Claude Code late 2024 knowing it lacked PMF for ~6 months — betting the next model closed the gap (Harness Shrinkage as Models Improve).
Software gets democratized. Printing Press Software Democratization: like literacy after Gutenberg, software-writing diffuses; "the best person to write accounting software is a really good accountant, not an engineer — coding is the easy part." Boris predicts ~10× more disruption-grade startups over the next decade.

Stance B — Pragmatist practitioner: "AI tools are powerful, but software-engineering fundamentals are the ceiling"#

Primary voice: Matt Pocock (independent AI-coding educator, built Sandcastle).

Fundamentals still apply. "We forget that software-engineering fundamentals — the stuff that's crucial to working with humans — also work super well with AI" (Matt Pocock). Cites Brooks, Pragmatic Programmer, Ousterhout, Fowler.
"Bad code bases make bad agents." Harness Shrinkage as Models Improve counterpoint: "If your code base doesn't have feedback loops, you're never ever ever going to get decent output out of AI. The quality of your feedback loops influences how good your AI can code. That is the ceiling." Tests, types, linters, isolated review contexts are infrastructure that does not migrate into the model.
Manage the context budget. Context Window Smart Zone: LLMs degrade quadratically with context (~100K-token "smart zone" regardless of advertised window); 1M-token windows "just shipped a lot more dumb zone." Prefer /clear over compaction.
Specs-to-code is "vibe coding by another name." The code is the battleground, not the spec; reach a shared design concept with the model before writing a plan (Design Concept Grilling).
Review is the unsolved 2026 problem. When agents ship more code, humans review more code — the durable bottleneck loops can't replace.
This matches the official tooling guidance: Claude Code Best Practices and Agent Harness Engineering both treat AI productivity as gated by environment design (CLAUDE.md/AGENTS.md as a table of contents, verification-driven loops, explore→plan→code).

Stance C — Skeptic / governance: "the risk isn't capability, it's how organizations frame and oversee it"#

Primary voice: Kropp, Bedard, Wiles, Hsu, Krayer (HBR, May 2026 + the 2026/03 "brain fry" paper) — the only randomized-experiment evidence in this wiki.

Anthropomorphizing AI erodes accountability. AI Employee Framing (n=1,261; effects concentrated in the ~23% whose orgs already put AI agents on org charts): framing an agent as an "employee" vs a "tool" — holding everything else constant — shifts personal accountability −9pp, raises attribution-to-AI +8pp, increases unnecessary escalation +44%, and reduces errors caught −18% — with no gain in adoption intent.
"Brain fry" is real and measurable. AI Brain Fry: mental fatigue from oversight beyond cognitive capacity correlates with +11% minor and +39% major error frequency. Tool framing taxes the reviewer; employee framing replaces the tax with under-engagement. Both framings have a cost surface.
What actually drives adoption is managerial role-modeling, not org-chart symbolism — AI-mature companies are 3.5× more likely to have managers visibly using AI in daily work (AI Employee Framing).
The fix is structural redesign, not "expand span of control": sample-based audit instead of every-output review, concentrate review on high-stakes decision points, shift humans from per-output review to system-level oversight, reset performance management to reward orchestration (Human-AI Accountability Redesign, AI Brain Fry).

Stance D — Architecture thesis: "the harness dissolves into the model — interaction included"#

Primary voices: Thinking Machines Lab (Interaction Models, May 2026); Sutton via The Bitter Lesson.

The bitter lesson recurs. The Bitter Lesson: scaled general methods beat hand-engineered structure. Across this wiki it's the load-bearing justification for dissolving harnesses into models — but with a caveat that mechanical verification and character may not migrate inward.
Interface, not just code. Interaction Models / Turn-Based Interface Bottleneck: today's turn-taking chat interface is itself a bandwidth bottleneck; the VAD/turn-detection/dialog-management harness should dissolve into the model. "Interactivity scales with intelligence only if it's in the model." This is the same harness-shrinkage move on the interaction axis.

Where the stances actually conflict#

Question	Bullish insider (A)	Pragmatist (B)	Skeptic (C)	Architecture (D)
Is coding "solved"?	Yes, for me, now	No — gated by codebase quality	Wrong question; oversight is the problem	Trending yes, structurally
Does the harness matter long-term?	Shrinks toward ~nothing	Verification half stays load-bearing	—	Dissolves into the model
Biggest risk	Building for the wrong (current) model	Bad feedback loops → bad agents	Diffused accountability, brain fry	Hand-engineered scaffolding outpaced
Evidence base	Internal anecdote, founder claims	Practitioner experience	Randomized experiment, n=1,261	New lab's architecture + benchmarks

A and B agree more than they appear to: Boris concedes the harness's verification layer persists; Pocock concedes implementation can go fully AFK. C is orthogonal — it's about org design, not model capability. D is the most speculative (a single lab's May-2026 thesis).

Part 2 — Futures of the software engineering role#

2.1 The core shift: from "writing code" to "deciding what to build + verifying it works"#

Cat Wu: "As code becomes much cheaper to write, the thing that becomes more valuable is deciding what to write" (Engineer PM Convergence).
Boris Cherny: the bottleneck moves from coding to domain knowledge — accountants/doctors/lawyers/teachers authoring tooling for their own domains (Printing Press Software Democratization).
The role splits roughly into three durable activities: (1) product/judgement — pick the right thing; (2) harness/environment engineering — design the scaffolding the agent works in; (3) verification & review — own the mechanical feedback loops and the fresh-context review (Learning to Co-Work with AI: A Software Engineer's Field Guide).

2.2 Roles converge; teams shrink#

Engineer PM Convergence: at Anthropic, every functional role on the Claude Code team writes code (EM, PM, designers, data scientist, finance, user researcher); engineers go "from Twitter feedback to shipped product by end of week with almost no product involvement." Hiring bias: "engineers with great product taste." Implications: hire for taste regardless of title, cross-train aggressively, smaller end-to-end-owning teams, lighter PRDs, fragmenting career ladders. Open question: does this scale past ~50-person teams? Boris hedges — "a question for years." A contrasting in-house view (Anthropic's Head of Growth) says fast-shipping engineers need more PM/design support, not less — i.e. team shape depends on org function.

2.3 What stays human (the appreciating skills)#

Code-review fluency — the new bottleneck once agents ship faster (Matt Pocock, AI Native Product Cadence).
Cross-functional EQ / tacit judgement — knowing the right venue, sensing when a launch is ready, what counts as a fair trade-off; Cat Wu explicitly names this as not merging into the model (Engineer PM Convergence).
Domain depth — the accountant-who-can-now-build beats the engineer with no domain (Printing Press Software Democratization).
Mission/values clarity as tiebreaker — collapses coordination cost (AI Native Product Cadence).
System-level oversight — orchestration quality, decision-rights gating, escalation design — explicitly the redesigned shape of the human-at-the-boundary role (Human-AI Accountability Redesign).
Harness/verification infrastructure — Pocock's "that is the ceiling"; the part of the scaffolding that doesn't migrate into the model (Harness Shrinkage as Models Improve).

2.4 Strategic positioning: which moats (and which careers) survive#

Seven Powers Applied to AI: switching costs and process power erode under AI (agents port integrations, hill-climb processes); network effects, scale economies, cornered resources persist; counter-positioning amplifies (AI-native startups pick models incumbents structurally can't follow). Applied to an individual career: "15 years of process knowledge nobody else has" is process-power that AI now hill-climbs; "a network of trusted relationships in this niche" is a network effect AI doesn't replicate. Build AI-native habits from scratch rather than bolting AI onto pre-AI workflows.

2.5 The honest uncertainty#

High confidence: coding skill becoming baseline; verification/review as durable; harness-prompt scaffolding shrinking per release; smart-zone context limits. Multiple converging sources.
Medium confidence: "100 lines of code" (hyperbole by Boris's own framing); printing-press timeline ("faster than 50 years," exact rate unknown); product-taste-as-bottleneck (true at small Anthropic-style teams, scaling unclear).
Counter-evidence worth weighting: the one rigorous empirical study here (AI Employee Framing) is a caution — anthropomorphized, org-charted AI diffuses accountability and degrades review without improving adoption. The bullish narrative leans heavily on Anthropic's own account plus one independent practitioner; treat it as well-grounded for individual workflow guidance, less battle-tested at organization scale.
Net: the "software engineer disappears" framing is not what these sources say. They say the median activity changes — less typing of code, more deciding/designing/verifying/overseeing — and the people who lose are those whose value was pure coding throughput or pure process knowledge; the people who gain are those with domain depth, judgement, and the discipline to engineer good feedback loops around agents.

Opinions on Using AI Tools & the Future of the Software Engineering Role