11) AI-spesial med Vilde Opsal og Anders Sveen

Truls Jørgensen og Audun Fauchald Strand — Heis Podcast · podcast · 2026-02-16 source ↗ Reader 🖥️

practical · mixed — A conversation that is mainly practical (how should developers and organizations adopt AI-assisted development right now?) but interleaves theoretical reflection on abstraction history (assembly → high-level → natural-language instruction) and on the limits of determinism. The hosts use the AI-special framing to push two complementary practitioners — an executive shepherding org-wide adoption and a hands-on senior — to make their working assumptions explicit.

Structure

Key terms

• kodeagent / code agent Coding Agents
  An LLM running in a loop with tool access that works *with* a developer on their local code, gated by the developer's review — distinct from an LLM that runs in production
• business agent
  An agent that runs in production, exposed to end-users or external systems — different risk profile than a code agent because the LLM itself is in the live request path
• vibe coding Vibe Coding
  Originally: explicitly not looking at the generated code. As actually used by most people: any LLM-driven coding. Anders distances himself: he uses LLM assistance but reviews tests and structure closely
• AI-augmented engineering / augmented engineering Agentic Engineering
  Vilde's house term at FINN/Vend for the developer-tooling track of AI adoption (as opposed to product agents or business agents)
• evals / smak / judgment Evals
  The capacity to look at AI output and tell whether it is good — both as ad-hoc human evaluation ('smak', taste) and as instrumented automated metrics
• guardrails Guardrails
  Structural constraints (tests, compilers, small commits to prod, type systems, minimal interfaces) that both keep humans and code agents on track — Truls frames them as what makes AI 'behaviorally deterministic' even when it isn't statistically so
• outsource the learning (du kan ikke outsource læringen) Learning Culture & Slack
  Vilde's slogan for refusing to delegate learning to the model — everyone at every level must try the tools themselves rather than wait for someone else to figure them out
• sustainable software (Charity Majors) Changeability & Optionality
  Anders borrows Charity Majors' top-of-pyramid category for software that has to live a long time and absorb changes — the regime where AI's speed gains do *not* dominate the work
• information architecture (in the AI context) Software Design Fundamentals
  Vilde: clear definitions, naming, structure, and consistent patterns — the thing that *still* matters most when LLMs do a lot of generation, because it determines whether the model can navigate the system
• remote agents / agent-team Multi-Agent Orchestration
  Vilde's near-term vision: not one agent paired with one human, but multiple agents (dependency police, vulnerability watch, code-review, consistency) running in parallel as teammates
• autonomy levels (Droid / Factory AI) Guardrails
  A model of staged AI permission: planning only → low-impact (reversible) → medium → high (destructive) — Anders endorses this as a useful way to ship LLM access without trusting the LLM
• prompt injection Agent Security
  An attack where content the LLM reads (web pages, files, mail) contains instructions that hijack the agent — explicitly named as inherent to how LLMs work, not fully solvable
• kode blir gratis ('code becomes free') Near-Zero-Cost Code
  Vilde's compact phrasing of the shift: some old engineering worries (over-engineering, premature abstraction) lose force when code is cheap to throw away — but information architecture worries do not

Propositions

• explicitcontestedAI-assisted coding is a genuine step-up in abstraction comparable to assembly → high-level languages or wiring → compilers — the code itself becomes more of a regenerable artifact than something humans hand-craft.conf: high
  contradicts ←[FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero · p5 — Pocock rejects the code-as-regenerable-artifact framing: specs-to-code is vibe coding renamed, and the code remains the developer's battleground.
• explicitdevelopedChasing determinism is a category error — the right goal is value delivery with sufficient control, not deterministic LLMs.conf: high
  refines ←Architecture as Code to Teach Humans and Agents About Architecture · p3 — Reconciles the 'chasing LLM determinism is a category error' claim: determinism belongs in the guardrails/constraints that define success, not in the model itself.
• explicitcontestedWhatever happens at the UI/front, the systems beneath need high determinism and consistent domain logic — you cannot 'just regenerate' a production codebase.conf: high
  contradictsThe Future Of Software Engineering · p14 — The Heis panel argues production systems need high determinism and cannot 'just be regenerated', against the vision of source code as a transient on-demand artifact.
• explicitestablishedInformation architecture (clear naming, structure, patterns, minimization, bounded changes) becomes *more* important — not less — under code agents, because the agents themselves respond better to structured codebases.conf: high
  supports ←Bliki: Vibe Coding · p7 — Fowler's claim that well-structured code makes LLMs more effective matches the Heis argument that information architecture becomes more important, not less, under code agents.
  supports ←Software Design X-Rays · p4 — Supplies the cognitive mechanism — code legibility as externalized support for a reader's mental schema — behind why clear information architecture should matter to both human and agent 'readers' of a codebase.
• explicitestablishedDORA-style empirics apply: AI is a force multiplier in both directions — strong teams get better, weak teams get worse faster.conf: high
  supportsPresentation: AI-First Software Delivery: Balancing Innovation with Proven Practices · p5 — DORA-style empirics confirm AI is a force multiplier in both directions: strong practices amplified, weak practices made worse faster.
  supports ←AI Enthusiasts Are in a Race Against Time, AI Skeptics Are in a Race Against Entropy · p10 — Both invoke the same DORA/Nathen Harvey finding that AI is a force multiplier in both directions — strong teams get better, weak teams get worse faster.
  supports ←We Studied 150 Developers Using AI (Here's What's Actually Changed...) · p6 — Both apply the DORA-style amplifier/force-multiplier framing: AI magnifies existing team strength or weakness.
  extends ←Don't Let AI Make Bad Analytics Worse · p2 — Extends the general 'AI is a force multiplier in both directions, strong get stronger / weak get weaker' amplifier thesis into a specific domain (analytics), naming the three tiers (efficiency/reliability/decision-quality) that separate weak from strong organizational responses.
  supports ←DORA Community Discussion - Operationalizing DORA within a large organization · p12 — 'AI is an amplifier, not a savior — without a strong foundation AI increases chaos' is the same amplification thesis as 'AI is a force multiplier in both directions: strong teams get better, weak teams get worse faster.'
• explicitFor seniors operating in domains they already know, code agents give roughly 10–40% productivity uplift, not a 2x.conf: high
• explicitThe bigger gain is *capability unlocking* — people now reach domains (Terraform, infra-as-code, foreign stacks) they could not before, so the productivity multiplier for novices/cross-domain work is effectively unbounded.conf: high
• explicitThere is a real disagreement on whether existing senior craft instincts (small commits, tests, modularity) will continue to matter or are senior 'tviholding'.conf: high
• explicitThere is a tension Vilde names but does not resolve: developers describe their existing codebases as 'high quality and under control' while reality (own past code, production incidents) doesn't match — so worrying that 'agents will pollute our nice code' starts from a false premise.conf: high
• explicitAI is a productivity transformer for prototyping and exploration; it is a much weaker advantage for systems where the bottleneck is interdisciplinary understanding (NAV dagpengesaksbehandling: law, jurists, politics).conf: high
• explicitcontestedReported developer happiness with code agents goes up while objective quality (issues in prod) goes down — feelings track tool affection more than outcomes.conf: medium
  contradictsThe Future Of Software Engineering · p4 — Both decouple developer sentiment from outcomes but in opposite directions: Heis reports happiness up while quality drops, Thoughtworks reports satisfaction down while output rises.
• explicitOrganizations should refuse to let any individual 'outsource the learning' — every level (developers, principals, CFOs, summer interns) must touch the tools themselves rather than wait for best practices.conf: high
• explicitcontestedThe senior/junior framing is more nuanced than the dominant narrative — seniors are *not* uniformly the big winners; many seniors fail to retool and stay at their old velocity, while juniors graduating now will have agent fluency baked in and 'run past us'.conf: high
  extends ←What is the harder human-capital problem beneath token capital? · p7 — Heis #13 complicates the seniors-always-win narrative (many seniors fail to retool while juniors 'run past us'). This essay extends it into a two-sided organizational trap — senior human capital too slow, junior human capital not yet deep enough — leaving the firm stuck between slow knowledge and fast ignorance.
  contradicts ←SMOC.AI's Post — 5 Minutter: AI og utviklere · p2 — SMOC asserts the plain 'seniors get superpowers, juniors do not' narrative that the Heis panel explicitly disputes, arguing seniors are not uniformly winners and agent-fluent juniors will overtake them.
• explicitGenerative-AI-augmented *teams* are an open research question — gains at the individual level are well-attested; team-level augmentation patterns are not yet figured out (citation to Nils Brede Moe on Heis).conf: high
  supports9) Nils Brede Moe om AI-paradokset, autonomi, læringskultur og fremtidens team · p21 — The panel explicitly cites Brede Moe in affirming that individual-level AI gains are well-attested while team-level augmentation patterns remain unsolved.
• explicitCode agents have full operator-level privileges on the developer's machine and send code/data to vendor servers — so adoption requires explicit DPA/database-handler agreements and active risk discussion, not just enthusiasm.conf: high
• explicitcorroboratedPrompt-injection style attacks are *intrinsic* to how LLMs work — vendors filter and harden, but you cannot make the class of risk go away while shipping computer-using agents broadly.conf: high
  supports ←Hacking Meta's AI Chatbot · p4 — A concrete exploited incident confirming that prompt-injection-style manipulation of LLMs is intrinsic: individual tactics get patched, the class does not go away.
  refines ←Running Python code in a sandbox with MicroPython and WASM · p6 — Accepts that prompt injection is intrinsic and specifies the highest-leverage mitigation: cut the exfiltration leg of the lethal trifecta.
• explicitMicrosoft / GitHub Copilot is a much weaker code agent than Claude Code; teams constrained by Microsoft licensing should look at open code coupled to GitHub Copilot's server side, or Droid (Factory AI) with selectable models.conf: high
• explicitcorroboratedStaged-autonomy frameworks (Droid: plan / low-impact / medium / high — keyed to reversibility) are a workable interim risk model for agent autonomy.conf: high
  supports ←Inside Claude Code Auto Mode: Anthropic's Autonomous Coding System with Human Approval Gates · p8 — Safety-as-spectrum converges with the staged-autonomy framework (Droid levels keyed to reversibility) as a graduated rather than binary risk model for agent autonomy.
• explicitThere is a software-type spectrum that determines whether AI uplift dominates: throwaway scripts (LLM-generated Python for one-off Excel filtering) at one end, Charity Majors' 'sustainable software' at the other; failing to make this distinction is the most common adoption mistake.conf: high
• explicitcorroboratedAn organization-scale adoption pattern that works: deliberately surface an *ordinary* team that succeeded (not just star individuals), run Slack channels (a 'fast' frontier one and a 'safe' learning one), workshops, internal blog summaries, and 'no opt-out' learning culture — supported by access to best-in-class tools.conf: high
  supports ←New Skills to Navigate Continuous Change · p8 — Merchant's claim that change spreads through organic team-to-team contagion rather than mandates supports the Heis panel's adoption pattern of surfacing an ordinary successful team as the diffusion mechanism.
• implicitImplicit/assumed: the unit of valuable change is the *judgment + evals + information architecture* stack, not the individual prompt — i.e., the durable engineering output is now organizational rather than per-developer.conf: medium
• implicitImplicit: there is a Norwegian/public-sector-shaped version of the AI-adoption question (compliance, jurists, persondata, sovereignty, DPA-with-Anthropic) that materially changes which tools are usable.conf: medium
• implicitcorroboratedImplicit: the 'AI replaces juniors' panic is misframed — the durable bottleneck is *evaluation capacity* (smak/judgment), which is hard to learn without doing the boring work that AI now hides; nobody on this panel has solved that.conf: high
  supports ←Human Oversight Is Not a Human in the Loop · p15 — Both identify the same durable bottleneck — evaluative judgment built through routine practice — as what erodes when AI absorbs the routine work that previously built and exercised it.

Arguments

Narratives

• Anders converts an Azure Bicep IaC project to Terraform with a code agent. He doesn't really know Bicep, knows some Terraform, gets the first conversion + double-check loop done in a way he calls 'helt magisk'.
  → Concrete illustration of capability-unlocking productivity rather than typing-speed productivity.
• A NAV developer working on dagpenger thinks ahead for three weeks before writing code; uses the agent mainly as a thinking partner, not to type faster, because the work is dominated by interdisciplinary alignment with jurists and political constraints.
  → Counter-example showing that AI does not collapse work where the bottleneck is shared understanding.
• Amazon agent buys products from third-party sites when customers order things Amazon doesn't stock; vendors are unhappy to find themselves on Amazon.
  → Illustration of business agents (LLM in production) creating real-world consequences outside the org's existing rails.
• Anders gives Claude/code agent access to OpenTelemetry production data; it analyses an error, finds the root cause, and *automatically opens a pull request* with a fix — full-stack agentic loop from prod telemetry to code change.
  → Anchors the unity's 'real step up in abstraction' claim — closes the production-to-code feedback loop a human would normally orchestrate manually.
• Vilde steps into a phone booth, voice-dictates a conference pitch as if babbling to the machine; what comes out is very different from what she would write fingertip-first.
  → Shows that the new modality (voice as input + agent loop) changes the *kind* of artifact a senior leader can produce, not just the speed.
• Vilde's team finds an 'ordinary' team that succeeded with code agents and uses *them* (not the star individuals) as the demo case so other teams can't dismiss the result as exceptional-person dependent.
  → Implicitly argues for selection bias as a core obstacle in tech adoption.
• Anders' attempt to plan a London trip with an agent: it works hard, takes a long time, doesn't deliver much value — contrasted with the Open Telemetry pull-request flow, which did.
  → Honesty marker — concrete failure case that disciplines the rest of the optimism.
• Anders and Truls/Audun shared a stage in 2011–12 talking about the importance of *removing* unnecessary complexity — a 15-year continuity that frames Anders' AI stance as 'the new tool for an old goal'.
  → Establishes the implicit premise that AI's value is judged against a long-held simplicity/clarity criterion, not against a productivity-only criterion.

Questions addressed

• ✅ What happens to software development when AI moves from helper-on-the-side to an integrated part of how teams build, test and deliver?
  Abstraction level rises; some old worries fade (over-engineering, perfect upfront design); judgment, evals and information architecture become the durable engineering work; team-level patterns remain open.
• ✅ How fast does AI actually make experienced developers?
  Anders' best-effort number is 10–40% for familiar work; Vilde reframes the question to 'effectively unbounded for work you couldn't otherwise do'; both reject the 2x headline.
• ⭕ Will juniors be able to learn the trade if agents do the early work for them?
  Both express concern; Vilde frames it as a recurring generational worry and notes some fears (e.g. 'they won't learn X') will turn out to be moot when X stops mattering, but neither claims to know how juniors will build judgment.
• ✅ How do organizations scale AI-coding adoption from a frontier individual to the whole engineering org?
  Vilde gives a concrete playbook (ordinary-team demos, two Slack channels, workshops, top-down 'no opt-out from learning', best tools provided).
• ✅ How should engineering teams reason about determinism when LLMs are in the system?
  Stop chasing statistical determinism; build behavioral determinism via guardrails (tests, small commits, structured code, evals); preserve domain consistency at the backend.
• ✅ What are the right risk frames for code agents and computer-using agents?
  Treat machine access as authorization escalation; require DPA agreements; gate autonomy by reversibility; accept that prompt injection cannot be fully eliminated.
• ⭕ Does AI augment teams the way it augments individuals?
  Both guests explicitly admit this is open; reference to Nils Brede Moe's research line.
• ⭕ How do we maintain the evaluation skill ('smak / judgment') when daily practice no longer drills it?
  Vilde insists 'don't outsource learning' and Anders flags the concern, but neither proposes a mechanism for sustaining evaluation skill across a workforce.

Gaps

• incompleteThe conversation explicitly opens but does not close the team-augmentation question — what does multi-agent + multi-human team coordination look like in practice? Vilde admits FINN/Vend has not cracked it.
  Read next: Nils Brede Moe (Heis ep 9) on AI paradox + autonomy + learning culture; Pocock workshop on harness design for long-running agent teams; emerging literature on multi-agent code review and orchestration.
• incompleteNo mechanism is offered for how juniors build judgment when boring drill-work is automated — both guests gesture at the problem and move on.
  Read next: Charity Majors on operability and on-call as learning; Ironies-of-Automation literature (already in user's library via the 'Ironies of A²I²' extraction); craftsmanship/apprenticeship literature.
  closed byLeadership Summit 2026: Inspiring Grit and Growth Amid Unprecedented Change — Duckworth offers a partial mechanism: delegate only the genuinely low-learning-curve, tedious tasks at the bottom of the goal hierarchy to AI, while treating AI's output on higher-value tasks as a demonstration to actively watch and imitate (explanation-demonstration-imitation-repetition), rather than assuming all automated drill-work is equally lost as a training opportunity.
• incompleteNorwegian/Nordic constraints (persondata, public-sector compliance, sovereignty, DPA-with-Anthropic) are mentioned repeatedly but never developed into a coherent picture of how the Norwegian stack will diverge from the US default agent stack.
  Read next: Smidigposten / Norwegian agile community pieces on public-sector AI; sovereign-AI / data residency discussions; Vipps/DNB/NAV-specific writeups.
• incompleteEvals come up as the durable skill, but the conversation never defines *what an eval actually looks like* for code-agent output (vs. business-agent product output). The asymmetry between 'evaluating an LLM in prod' and 'evaluating an LLM-generated diff' is not surfaced.
  Read next: Anthropic and Hamel Husain writing on LLM evals; Tobias Torrissen on kodekvalitet + AI (Heis ep 13).
  closed byDoorDash Used Copilot to Convert Its XCTest-Based iOS Test Suite to Swift Testing — Gives a concrete worked example of what an eval for code-agent output looks like: a deterministic ten-consecutive-pass reliability gate applied to each AI-migrated test before acceptance.
• incompleteBoth guests work with code agents that have full machine privileges but the autonomy-level framework (Droid) is mentioned only as a stopgap. There is no working theory of what the *next* sandbox abstraction should look like.
  Read next: Anthropic's harness/agent SDK posts; container-level sandboxing approaches; Cloudflare Mythos / OS-level isolation for agents.
  closed byRunning Python code in a sandbox with MicroPython and WASM — Willison offers a concrete next sandbox abstraction beyond staged-autonomy stopgaps: a WASM/MicroPython execution boundary as the unit of safety for agent-generated code, with blast-radius containment rather than trust in model intentions.
• uninformed (in a time-stamped sense)The episode is explicitly dated end of January 2026 and pre-DeepSick announcement; the participants flag this themselves.
  Read next: Re-listen after major model releases; compare against follow-up Heis special when produced.

Closes gaps elsewhere

• Agents don't know what good looks like. And that's exactly the problem. · g5 — Supplies the regulatory/legal layer the essay omitted: agent adoption requires explicit DPA/data-handler agreements, persondata and sovereignty constraints, and active risk discussion, with a Norwegian public-sector-shaped compliance picture.
• 9) Nils Brede Moe om AI-paradokset, autonomi, læringskultur og fremtidens team · g4 — Describes a working organization-scale propagation pattern for AI learning across teams: surface an ordinary team that succeeded, run fast and safe Slack channels, workshops, internal blog summaries, and a no-opt-out learning culture.

Related documents

• 9) Nils Brede Moe om AI-paradokset, autonomi, læringskultur og fremtidens team
• The New SDLC With Vibe Coding: From ad-hoc prompting to Agentic Engineering
  Agentic Engineering Coding Agents Evals Guardrails
• [FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero
  Agentic Engineering Coding Agents Multi-Agent Orchestration Software Design Fundamentals
• Vibe Coding Agent Security And Evaluation
  Agent Security Agentic Engineering Evals Vibe Coding
• Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
  Agentic Engineering Coding Agents Multi-Agent Orchestration Vibe Coding
• Looking back at the Future of Software Engineering unconference
  Agentic Engineering Guardrails Multi-Agent Orchestration Vibe Coding
• SWLW #701: Gazing at the misty AI Frontier, From Vibe Coding to Agentic Engineering, and more.
  Agentic Engineering Learning Culture & Slack Software Design Fundamentals Vibe Coding
• Vibe coding and agentic engineering are getting closer than I'd like
  Agentic Engineering Coding Agents Near-Zero-Cost Code Vibe Coding
• Agent Skills: Google-Backed AI Coding Agent Workflow
  Agentic Engineering Coding Agents Guardrails
• Have your agent record video demos of its work with shot-scraper video
  Agentic Engineering Coding Agents Multi-Agent Orchestration