Looking back at the Future of Software Engineering unconference
Bartosz Ocytko · article · 2026-07-07 source ↗ Reader 🖥️
Agent ObservabilityAgentic EngineeringAgentic LoopAI as AmplifierCitizen DeveloperGuardrailsHuman-in-the-LoopLong-Running & Managed AgentsMulti-Agent OrchestrationNon-Engineers BuildingPlatform EngineeringSoftware FactoryThey Build It, You Run ItVibe Coding
As agentic engineering matures into human-built-and-operated 'software factories,' the decisive questions of software engineering shift from raw automation to governance — where human judgment and sign-off sit in the automated loop, how platforms (rather than universal upskilling) safely absorb citizen developers, what would keep developer tooling relevant, and how organizations manage the widening gap between teams that codify their processes early and those that don't.
practical · expository — A practitioner's reflection organizing four themes from an unconference into a forward-looking view of agentic software engineering; largely expository and prescriptive, with predictive threads about where the discipline is heading.
Structure
| Part | Role |
|---|---|
| Software factories | Establishes the aspirational endpoint — a self-evolving delivery system — and locates the enduring human role at the 'backbone that builds the system' plus explicit hand-off/sign-off points |
| 'You build it, you run it' vs. 'They build it, you run it' | Examines operational ownership as citizen developers enter; argues platforms that separate concerns (not universal upskilling) are the better path to absorb them safely |
| Will we still need IDEs? | Examines the tooling substrate — why IDEs are being bypassed for coding CLIs and what agent-oriented features would keep them relevant |
| Growing gaps | Examines the organizational consequence — amplification widens the gap between fast and slow adapters; small firms gain first, large firms risk fragmentation; identity/innovation limits constrain a unified process |
| Closing reflection | Acknowledges that human-judgment locations are clearer than winning organizational shapes, and calls for practitioner leadership over social-media hype |
Key terms
- software factory Software Factory
The human-built-and-operated backbone that builds the software system — the automated delivery machine that codifies development steps into reusable agentic loops — as distinct from the product it produces; developers build, operate, and set the constraints under which it is allowed to evolve - hand-off points
Explicit points in an otherwise automated pipeline where human interaction and sign-off is required — idea→plan, plan→execute, change-request→deploy, incident→remediation — chosen according to business needs and appetite for risk - citizen developers Citizen Developer
Non-engineers who build applications with AI assistance, without traditional software-engineering training - background agents / guardrail agents
Highly specialized, increasingly autonomous agents that compensate for lower-quality code produced by coding agents and protect system invariants — e.g. refactoring code, applying reliability patterns, writing missing tests, reorganizing test suites to cut execution time - growing gaps
The widening divergence between teams/companies that codified their processes early and reap agentic acceleration and peers who are slow to adapt
Propositions
- explicitdevelopedThe endpoint of agentic engineering is a largely self-evolving 'software factory' in which a feature request is built into the existing system, and which humans build and operate rather than hand-code.conf: mediumrefines ←Software Factories, Light and Dark · p1 — Gives the 'software factory' endpoint a concrete queue -> harness -> review-gate -> deploy wiring diagram and an 'org chart made of loops' framing, sharpening the vaguer 'self-evolving system that builds a feature into the existing system' definition.
- explicitA single bug or feature request can now be designed, coded, and verified end-to-end in an agentic loop when supported by the right tools, platform, and guardrails.conf: high
- explicitTeams with well-engineered systems — low build times, modular architecture, and high test coverage enabling continuous delivery — benefit most from agentic engineering.conf: high
- explicitBetter models enabling multi-hour execution drive agents off local developer machines onto hosted micro VMs, accelerating migrations and codebase modernization.conf: medium
- explicitdevelopedHighly specialized autonomous background 'guardrail' agents (refactoring, reliability patterns, writing missing tests, reorganizing test suites) compensate for the lower-quality code produced by coding agents and protect system invariants and stability.conf: mediumextends ←Software Teaming in the Age of AI with James Herr and Woody Zuill · p5 — Gives a concrete working instance of the generic claim that specialized autonomous background 'guardrail' agents (writing missing tests, reorganizing test suites) compensate for lower-quality agent-generated code: Chris's standing mutation-testing/mutant-hunting agent.
- explicitFor the foreseeable future the developer's role is to build and operate the backbone that builds the system and to set the constraints under which the system is allowed to evolve, rather than to write the application code.conf: high
- explicitHuman judgment should be anchored at a small set of explicit hand-off/sign-off points — idea→plan, plan→execute, change-request→deploy, incident→remediation — selected according to business needs and appetite for risk.conf: high
- explicitcontestedAs citizen developers gain the ability to build apps with AI, organizations risk drifting back to a 'they build it, you run it' model that dumps operational ownership of AI-generated apps onto an existing engineering team.conf: highcontradicts ←Everyone wants to be AI-pilled. Most Companies Are Still Level 1 · p5 — This thread frames non-engineers authoring and shipping production tools (L4) as an unambiguous maturity signal; the other source warns the same pattern risks organizations drifting back into a 'they build it, you run it' model that dumps unsupported operational ownership onto citizen developers — a risk this thread does not acknowledge.
- explicitdevelopedPlatforms that separate concerns and offer safe user-level abstractions on a self-healing foundation — with tight, low-friction constraints that guide both the citizen developer and their agent from the first prompt — are a better path to absorb citizen developers than requiring everyone to acquire a baseline set of software-engineering skills.conf: highsupportsThe Organization Is the Bottleneck · p11 — Both frame platform-defined constraints (templates/golden paths/tight constraints) as simultaneously enabling human builders and constraining their agents; here the constraints guide the citizen developer and their agent from the first prompt.extends ←Presentation: A Few Predicted Talks From QConAI 2030 · p8 — Arik predicts IT becomes a platform team managing thousands of citizen-developer-built apps; the other piece already works out a more concrete architectural mechanism (self-healing platform foundation with tight, low-friction constraints) for exactly this scenario.
- explicitExisting vibe-coding vendor tools fall short at safely accessing production data and APIs, leading to static data embedded in apps that bypasses access control or leaks it, so the platform itself must ship access and data guardrails.conf: highrefinesBliki: Vibe Coding · p6 — Specifies the concrete mechanism behind vibe coding's security risk: vendor tools can't safely reach production data/APIs, so static data gets embedded, bypassing access control or leaking it — pointing to platform-level data guardrails as the fix.
- explicitPopular coding-agent plugins reduce the IDE to a chat/terminal window, making it easy to skip IDEs entirely for barebones coding CLIs that work well enough; IDEs could counter this migration by exposing deterministic refactoring tools, compilation/test access, agent-output annotation, native agent-skill support, multi-session orchestration, and agent-trace/telemetry insights — likely bundled into a new product.conf: medium
- explicitAgentic engineering amplifies both good and bad team practices, so teams that codify their processes early continuously widen the gap over slower-adapting peers — small companies gain first, while large companies risk process and tech-stack fragmentation unless shared skill marketplaces, tooling, and a culture of reuse take hold.conf: highextendsPresentation: AI-First Software Delivery: Balancing Innovation with Proven Practices · p5 — Adds a temporal-divergence dynamic to the amplification thesis: because agentic engineering amplifies existing practice, early process-codifiers continuously widen the gap over slow adapters, with small firms gaining first and large firms risking fragmentation.
- explicitA platform-imposed unified build process — even with extension points — will meet resistance and can limit innovation, because individual working styles and practices are part of engineers' identity and skill differentiation.conf: medium
- implicitThe binding constraint of software delivery is shifting from writing code to designing, constraining, and governing the automated system that writes it.conf: medium
Arguments
Platforms that separate concerns, not universal software-engineering upskilling, are the right way to safely absorb citizen developers. strength: medium
Explicit premises:
- With AI, citizen developers can build applications but tempt organizations back into 'they build it, you run it'.
- Training citizen developers to have risk intuition pays off, but requiring everyone to acquire baseline engineering skills is not the only path.
- Platforms can offer user-level abstractions on a self-healing foundation and ship access/data guardrails that make failure modes disappear.
Implicit premises:
- Baseline engineering competence cannot be scaled to every citizen developer quickly enough.
- Encoding safety into a shared platform is cheaper and more reliable than distributing that responsibility to each non-engineer.
Inferences:
- Therefore the burden of safe operation should be absorbed by a constrained platform rather than by upskilling every builder or by an engineering team operating others' apps.
Human judgment remains essential but should be concentrated at a few explicit hand-off points rather than spread across the whole pipeline. strength: medium
Explicit premises:
- The rest of the loop (implementation, verification, remediation collection) can be automated with the right tools and guardrails.
- Each hand-off (idea→plan, plan→execute, change-request→deploy, incident→remediation) is a natural anchor where business knowledge and trade-offs matter.
- Each hand-off can itself be augmented — risk measures, spec/regulatory checks, auto-collected incident summaries — to support the decision.
Implicit premises:
- Concentrating judgment at defined checkpoints keeps delivery legible and in check without blocking automation everywhere.
- The chosen checkpoints correspond to where irreversible or high-stakes decisions actually occur.
Inferences:
- Therefore explicit, augmentable hand-off points are the mechanism for keeping human oversight meaningful in an automated factory.
Agentic engineering will widen the gap between organizations, favoring early process-codifiers and small teams. strength: high
Explicit premises:
- Agentic engineering amplifies both good and bad practices.
- It is easier for one member of a small team to build shared guardrails and skills in code.
- Existing companies risk fragmentation on process and tech stack, and shared-tooling efforts depend on org structure and reuse culture.
Implicit premises:
- Amplification compounds over time rather than being a one-off boost.
- Organizational structure and culture change more slowly than the tooling that rewards codification.
Inferences:
- Therefore divergence between fast and slow adapters is the expected trajectory absent deliberate investment in shared platforms and reuse.
Narratives
- The 'holy grail' of a self-evolving system where a feature request is 'magically built' into the existing system, from which the author derives the name 'software factory' — the backbone that humans build and operate.
→ Frames the aspirational endpoint of the whole piece and fixes the enduring human role (building/operating/constraining the factory) against it - The self-healing database example: a foundation that automatically increases volume before running out of space or adds an index to speed up expensive queries, making those failure modes 'disappear' for the user within set constraints.
→ Concretizes how a platform can absorb operational concerns so citizen developers need not know about them from the outset
Questions addressed
- ✅ Where do developers sit in the automated software-factory process?
They build and operate the backbone that builds the system and set the constraints under which it evolves, exercising judgment at explicit hand-off/sign-off points chosen by business need and risk appetite. - ✅ How do we avoid a culture of throwing AI-generated apps over the fence for others to operate?
Partly by training citizen developers' risk intuition, but chiefly by building platforms that separate concerns, offer safe abstractions on a self-healing foundation, and ship access/data guardrails. - ⭕ Will we still need IDEs?
IDEs are increasingly bypassed for coding CLIs, but could remain relevant by exposing deterministic tools, compilation/test access, agent-output annotation, agent-skill support, multi-session orchestration, and telemetry insights — likely as a new bundled product. - ⭕ What organizational structures and team shapes will succeed with agentic engineering?
Left explicitly open: it is clearer where human judgement is needed than what org shapes will prevail or correlate with successful outcomes.
Gaps
- incompleteThe piece asserts that autonomous background 'guardrail' agents can compensate for lower-quality code produced by coding agents, but does not address how the guardrail agents' own reliability is assured or what happens when guardrail and coding agents conflict — a potential who-guards-the-guards regress.
Read next: Read on generator/evaluator separation, eval design for autonomous guardrails, and reliability of agent-checking-agent arrangements. - incompleteThe 'software factory' vision presupposes teams that already have low build times, modular architecture, and high test coverage; it does not explain how the large population of teams without those prerequisites gets there, leaving the later 'growing gaps' under-explained as remediable rather than fixed.
Read next: Read on bootstrapping engineering rigour and modernization with agents (legacy modernization, test-suite generation, CI/CD adoption paths). - incompleteHand-off points are proposed as anchors for human judgment, but the piece does not grapple with whether humans can keep up reviewing plans, change requests, and remediations at agentic throughput — the review/orchestration bottleneck.
Read next: Read on the orchestration tax and the human-review bottleneck in agent-heavy delivery pipelines. - incompleteThe piece argues platforms (not universal upskilling) should safely contain citizen developers with tight constraints, yet also warns that forcing a unified platform process on engineers is too constraining and harms innovation; it does not reconcile how one platform can be tight enough for non-engineers and loose enough for expert engineers' identity and innovation.
Read next: Read on platform-as-a-product tensions, extension points, and the golden-path-versus-team-autonomy balance.
Related documents
- AI Is Changing Software Engineering. The Fundamentals Still Matter.
- [FULL WORKSHOP] AI Coding For Real Engineers - Matt Pocock, AI Hero
- The "funhouse mirror": How AI reflects the hidden truths of your software pipeline
- 11) AI-spesial med Vilde Opsal og Anders Sveen
- The New SDLC With Vibe Coding: From ad-hoc prompting to Agentic Engineering
- The Self-Building Agent: A LangChain4j Experiment
- What the Hell Is a Loop, Anyway?
- What's an Orchestrator—and Why Does Software Need One?
- 11 Tips For AI Coding With Ralph Wiggum
- Software Factories, Light and Dark