Skip to content

About

Benedikt Stemmildt

Founder & Co-CEO

Portrait of Benedikt Stemmildt

Benedikt Stemmildt is Founder & Co-CEO of hackers&wizards in Hamburg, which runs AI training and mentoring in agentic engineering for engineering and product teams, so that the speed they gain shows up for their customers. He has been a technologist since he was a kid, and for twenty years one thing has driven him: developers in flow, building great products. He co-wrote Building the Agentic Software Factory with Alex Merced (Packt), hosts the Rethink Engineering podcast, is program chair of code.talks and curates CASE Berlin. Before that he worked as an engineer, architect and CIO at OTTO, Breuninger and BLUME2000.

Topics

Book 1

Book

  1. Building the Agentic Software Factory Scaling reliable AI coding practices from individual developers to teams Book
Talks 6

Talks

  1. How to Safely Run Your Agent in YOLO Mode Benedikt shows how Dev Containers and ClaudeBox let agents install packages, change files and run commands while your main system stays protected. 24 min
  2. No More Broken Handoffs between Product & Engineering Zamina and Benedikt on why broken handoffs, not tools or skills, slow product and engineering, and how shared live prototypes replace static specs. 21 min
  3. Vibe-Coding Is Killing Your AI Productivity You tried GitHub Copilot, ChatGPT, even Claude. But instead of productivity gains, you got messy code and frustrated teams. 49 min
  4. Why Vibe-Coding Fails (And How to Fix It) Why vibe coding gives messy code and how agentic engineering with feedback loops fixes it: a live demo building a feature inside a legacy app.
  5. Agents Across the SDLC: From Refinement to Retro Benedikt shows how specialized agents work across the whole software lifecycle, from refinement and planning to retrospectives, while people keep control. 66 min
  6. Stop Building Features. Build the Factory That Builds Them. Stop building features with an agent and build the production line that builds them, from ticket to pull request: a real client factory, opened live. 26 min
Podcast episodes 3

Podcast episodes

  1. Patrick Debois: Your Software Factory Should Be a Dream Factory 55 minHost, Rethink Engineering
  2. Sam Newman on Software Factories: Why AI Can't Fix Your Production Incidents (Yet) 59 minHost, Rethink Engineering
  3. Inside Steve Yegge's Software Factory: Lessons from Running 50 Agents 70 minHost, Rethink Engineering
Upcoming events 8

Upcoming events

  1. code.talks 2026 Two days, 14 tracks and more than 100 sessions for developers and CTOs codetalks.comHamburg (opens in a new tab)
  2. alphalist CTO Summit 2026 For CTOs in the alphalist community EventsHamburg
  3. Digitale Leute Summit 2026 Software Factories: Engineering on Autopilot digitale-leute.deCologne (opens in a new tab)
  4. alphalist Dev Bootcamp Berlin Building the Agentic R&D Organization bootcamp.alphalist.comBerlin (opens in a new tab)
  5. LangChain x hackers&wizards Hackathon An evening hackathon on agent harnesses, hosted by LangChain with AI Nights ainights.aiHamburg (opens in a new tab)
  6. OOP 2027 Building the Dark Factory: When Agents Run the Whole SDLC oop-konferenz.deMunich (opens in a new tab)
  7. CASE Berlin 2027 Building the Agentic R&D Organization case-conf.comBerlin (opens in a new tab)
  8. AXDN 27 One day on AI for CTOs and heads of engineering, six tracks axdn.ioNuremberg (opens in a new tab)
Trainings 1

Trainings

  1. Agentic Engineering for Engineering and Product Leaders Your leaders know how AI agents change their teams' roles and rituals, and lead that change. Trainings
Articles 25

Articles

  1. Measuring AI impact on engineering: what to count and what to ignore Code volume, pull requests, usage: AI pushes up every number that is easy to count. A Stanford talk and DX data put the measured gain at around 10 percent, and it swings widely from company to company. What to measure instead, where the returns come from, and why things get worse before they get better. 13 min read Measuring AI impact
  2. Breaking the Loop: Why agents never finish on their own Agents in a software factory always find another problem, another ticket, another improvement. Only a second, much slower loop can say when the work is finished: the one that reaches the market. 22 min read Specification and review
  3. A label on an issue is the whole protocol between agents The development-workflow skill in the software-factory.dev factory is the factory's own map of itself. It shows that the automations never call each other: they coordinate through labels on issues. 2 min read Software Factory
  4. Report the daily delta, not the total that only goes up The Tweet Drafter in the software-factory.dev factory posts updates three times a day and reports the daily delta, not the cumulative total, because a total always looks like progress. 2 min read Measuring AI impact
  5. An automated status report is only as honest as its prompt The weekly recap automation in the software-factory.dev factory stays honest because the honesty is written into its prompt: the challenges section is what makes it authentic, and an unrecorded number has to be named as unrecorded. 2 min read Software Factory
  6. A metric without a red line is decoration The weekly Performance Monitor in the software-factory.dev factory works because every metric it watches has a hard threshold written into it. 2 min read Measuring AI impact
  7. An automation that audits the factory must not rewrite its own record The automation auditor in the software-factory.dev factory inspects every other automation on the line. Its most useful rule: it may never overwrite last week's audit. 2 min read Software Factory
  8. Escalated work needs a return path back onto the line The smallest automation in the software-factory.dev factory puts escalated issues back on the line once a human has answered. The return path from human to machine needs its own owner. 2 min read Software Factory
  9. Set the stale-work clock from your agents' cycle time The Stale-Issue Reviewer at software-factory.dev calls work stale after three hours, not three days, because a watcher's clock has to run at the speed of the line it watches. 2 min read Software Factory
  10. The PR Shepherd resolves only the conflicts it understands The PR Shepherd in the software-factory.dev factory rebases conflicted pull requests but hands semantic conflicts to a human. The hard part of automation is encoding where its competence ends. 2 min read Software Factory

BlogAll 25 articles in the archive

Knowledge pages 109

Knowledge pages

  1. Agentic Engineering
  2. AEMM industry evidence
  3. Architecture and Design
  4. Agent-authored video
  5. Architecting agentic systems
  6. Architecture work in the agentic era
  7. Build versus buy
  8. Modernization and interface design
  9. Specifications, tests, and context
  10. Memory and Context Engineering
Show 99 more
  1. Persistent agent memory
  2. Just-in-time retrieval
  3. Context as a versioned artifact
  4. Methodologies and Frameworks
  5. The agent loop
  6. The disciplined compounding loop
  7. Human accountability
  8. Spec-driven development
  9. Quality and Verification
  10. Agentic continuous delivery
  11. Coding benchmarks
  12. Deterministic quality gates
  13. Evaluating non-deterministic systems
  14. Quality and productivity metrics
  15. The surrounding quality system
  16. The velocity trap
  17. Evidence
  18. AI productivity studies: METR, Stanford, DORA and Multitudes
  19. Amazon Cost to Serve Software (CTS-SW)
  20. The DORA report on AI-assisted development
  21. The DX AI-assisted engineering impact report
  22. Moving away from Agile: McKinsey's AI operating-model research
  23. Vouch in Ghostty: trust-gating open-source contributions
  24. The State of AI-Native Engineering report
  25. Getting Started
  26. Getting Started and Learning
  27. Effective beginner practices
  28. Deliberate practice
  29. Engineering foundations
  30. The junior learning path
  31. Verification literacy
  32. The learning curve
  33. Organizational learning
  34. Adoption gaps and resistance
  35. Productivity and Workflow
  36. What moves adoption
  37. Productivity evidence and quality
  38. Measuring impact
  39. Practitioner practices
  40. Where gains and losses occur
  41. Agent instructions (CLAUDE.md, AGENTS.md)
  42. Automation catalog
  43. Context window
  44. Hooks
  45. Quality gates
  46. Research, Plan, Implement (RPI)
  47. Spec-driven development
  48. Vibe coding
  49. Leadership
  50. Dynamic-robust organization
  51. Leading AI Adoption
  52. Product Management
  53. Software Engineering
  54. Architecture Principles
  55. Build or Buy Framework
  56. Engineering Manifesto
  57. Engineering Philosophy
  58. The Five Ideals
  59. The Three Ways
  60. Senior Engineering Skills
  61. Software Factories
  62. Dark Factory Patterns
  63. The Federated Factory at Enterprise Scale
  64. Multi-Agent and Orchestration
  65. Creator and verifier roles
  66. Security and Runtime Isolation
  67. Contributor trust and dual use
  68. Software Factories and Harness Engineering
  69. Agent observability
  70. The enabling environment
  71. Factory roles and pipeline
  72. Harness foundations
  73. Harness maintenance
  74. The software-factory pattern
  75. Production evidence
  76. Roles and economics
  77. Work and orchestration
  78. Tools
  79. AI Coding Tools
  80. Context and productivity
  81. Pricing agentic coding
  82. Security of autonomous coding agents
  83. Supervision and drift
  84. AI Models and Inference
  85. Inference economics and infrastructure
  86. Choosing models
  87. Structured model output
  88. Claude Code
  89. Claude Code Ecosystem
  90. Authoring skills and subagents
  91. Authoring skills
  92. Context and output interfaces
  93. Ecosystem and extension model
  94. The thin-harness ecosystem
  95. Evaluation and economics
  96. Context Engineering
  97. Prompt Engineering
  98. Designing efficient agent interfaces
  99. Protocol and context cost

Talk to Benedikt

Tell us where your team is today, and we'll work out the next step with you.

Write to Benedikt Book a call (opens in a new tab)