Andreas Heige

Talk · GitHub Copilot DevDays Gothenburg · 15 October 2026 · 48 slides

Throw away your IDE?

Agents, harnesses and cost-aware engineering work

  1. Opening slide: a terminal prints echo hello, then Hello. Andreas Heige.
  2. A question first: what did you open first this morning? An editor, a terminal, a ticket or a chat.
  3. Title slide: Throw away your IDE? Agents, harnesses and cost-aware engineering work, beside a Copilot CLI session fixing a cart bug.
  4. The shift: work now starts with a contract. Before, open the IDE and hope CI passes. Now, issue, acceptance contract, agent session, evidence, human decision.
  5. The terminal is now a full agent: reads the repo, edits files, runs commands, uses MCP, hooks, subagents and resumes long sessions.
  6. Today: four parts, one loop. What we built, what we learned the hard way, the lean harness, and people make it real.
  7. Part 01, what we built: a real harness in a large e-commerce monorepo.
  8. One monorepo, one .github folder: 18 instruction files, 19 specialist agents, 35 skills and 14 prompts, all versioned in git.
  9. Four layers, four triggers: instructions, skills, agents and prompts, with where each lives, how it activates and an example.
  10. The one equation: Agent = Model + Harness. The model is rented and swappable; the harness is where reliability is won.
  11. One file opened, 10 files load: seven always-on instruction files plus pattern-matched ones, without a single click.
  12. When rules conflict: security always wins, then domain, global and operational. One precedence file decides the order.
  13. The orchestrated pipeline: scope, analyse, develop, integrate, gates, ship. Shared memory wraps every stage; a FAIL goes back to develop.
  14. Binding gates before anything ships: a code quality gate, a security reviewer and QA. A FAIL blocks integration and sends the work back.
  15. Shared memory: read, work, write. Git-backed, never expires, reviewed in pull requests, with a small index always read first.
  16. Five model tiers, start cheap and escalate: economy 0.33x, standard 1x, mid 3x, upper 6 to 9x, premium 15 to 27x per request.
  17. The harness keeps itself current: a scheduled workflow re-syncs the model catalogue twice a month, or on demand, when prices change.
  18. One prompt, a whole workflow: a Copilot CLI session reads the ticket and Figma design over MCP, maps affected files and waits for your yes.
  19. Part 02, what we learned the hard way: the expensive lessons, so you do not have to pay for them.
  20. The biggest lesson, fan-out: more agents, more interactions. Renaming one button label spun up a top-tier orchestrator and five agents.
  21. Faster code moves the queue downstream: development speeds up, review and QA queues build, deploy keeps the same cadence.
  22. There is no single AI developer: power users, individuals and the hesitant each need a different approach.
  23. A rigid pipeline invites workarounds: plan, architect, implement, review, learn. Plans drift, learnings go stale and trust drops.
  24. Standardise capabilities, not every step: skills for workflow, scaffolding and tickets matter more than a fixed process.
  25. Context is a budget, sessions and tools: context rot and tool overhead, countered by short focused sessions and fewer enabled tools.
  26. Context is a budget, rules and memory: rule sprawl and memory growth, countered by a small always-on core and detail moved into skills.
  27. What actually drives the bill: tokens repeated every turn, tool schemas and each subagent's own model loop. Model price matters less.
  28. Pick the setup once per phase: our old guide said switch models freely; now choose once and keep it stable, as changes invalidate the prompt cache.
  29. Tokens used are not work done: measure accepted changes, defects found in review, time from issue to merge and retries per task.
  30. Part 03, the lean harness: same packaging, less ceremony, built for today's routing, caching and billing.
  31. Keep the packaging, cut the ceremony: keep installers, narrow agents and gates; change automatic fan-out to an explicit delegation gate.
  32. Contract, control, evidence: repository instructions, profiles for routing and credit caps, then deterministic checks before model review.
  33. One phase per session: research read-only, build in an isolated worktree from an accepted plan, review in a fresh read-only session.
  34. Choose the budget before you start: Quick 35, Standard 100, Deep 250 and Security 300 credits, with matching reasoning levels.
  35. The delegation gate: five questions on separate files, clear output, time saved, cheaper specialist and review cost. Five yes means delegate.
  36. When parallel agents pay off: good for independent audits and multi-model review; poor for several agents on one core module.
  37. Autonomy needs verification by design: interactive, plan and autopilot modes. Autopilot is not unchecked; the checks are part of the loop.
  38. The safety envelope: isolate in a worktree or sandbox, allow the narrowest commands, verify with a check command and diff review.
  39. CI is the referee: build, typecheck, lint with zero warnings, tests, a container scan and model review for what tests cannot see.
  40. Documentation is part of the system: code, docs and learnings change in the same pull request and feed the next agent session.
  41. The desktop app as control plane: the CLI is the reproducible interface; the desktop app supervises with chats, worktrees and a diff view.
  42. Issue, build, prove: a cart bug becomes acceptance criteria and a plan, a failing test and minimal fix in a worktree, then checks and diff review.
  43. Part 04, people make it real: the model is the easy part.
  44. Two ways to get it wrong: FOMO, trying everything and finishing nothing, or a local optimum, changing nothing. Balance with small experiments.
  45. Tooling moves faster than your process: build for the problem, expect the vendor to ship what you built by hand, keep the process elastic.
  46. Start on Monday: one repo and one task type, a small core, a baseline, skills on demand, then share and prune.
  47. Closing thought: the IDE becomes a precision tool. Start with the problem and its contract; open the editor for precise direct manipulation.
  48. Index of sources: further reading by slide, with the documentation each claim comes from.

The IDE becomes a precision tool. Open it when direct manipulation is the fastest way to a precise answer.