AI Engineer Europe 2026

Agentic Engineering: Working With AI, Not Just Using It — Brendan O'Leary

Loading slides…

Read the talk

Agentic Engineering: Working With AI, Not Just Using It

Effective collaboration with coding agents starts with deciding what to delegate, curating their context, and reviewing research and plans before assumptions become code.

From a talk by Brendan O'Leary

Before you start: Familiarity with Git, pull requests, and basic coding-agent use will help you apply the workflow.

Can you explain your AI workflow?

How are you using AI in your work? An answer such as “it helps me code faster” leaves the engineering decisions unexplained. What do you hand off? What do you keep? How do you decide between them? Brendan O’Leary opens with these questions because adoption alone says little about whether a team has a useful collaboration workflow.

O’Leary estimates that 90% of engineers have used AI tools and perhaps half use them regularly. He does not identify a survey for those estimates. His practical question is whether that usage amounts to more than accepting completions throughout the day: can engineers articulate how they work with the system?

The progression he sketches changes the unit of delegation:

StageWhat the developer hands overWhat comes back
Early 2020s: autocompleteA partial line or function signatureA suggested continuation
2022: copilotsA description of a functionA possible implementation
2025 onward: agentsA taskFile changes, test results, and potentially a pull request

In this account, GitHub Copilot helped make code generation broadly useful. The later shift is from suggesting code to executing a sequence: decompose the task, identify affected files, make changes, run tests, and return work for review.

The Paradigm Shift slide shows 2020 autocomplete, 2022 copilots, and 2025+ agents, with a highlighted AI-at-work statistic below.Open full source frame
From autocomplete to copilots to agents that execute tasks.

O’Leary invokes Flask creator Armin Ronacher’s distinction between using machines and working with them. You pick up a hammer, use it, and put it down. A coding agent occupies a different place in the workflow: it can carry work forward between your interventions. The playful comparison is another engineer who has read every Stack Overflow answer. That breadth is useful, but it does not settle who supplies judgment.

0:000:11
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:00 · section reference included

Fast, well-read, and confidently wrong

Think of the agent as an energetic, enthusiastic, extremely well-read junior developer who can be confidently wrong. It works quickly, does not tire easily, and has no ego about rewriting something six times. It brings familiarity with many languages, frameworks, and patterns. Those strengths make it a capable contributor, but they do not give it your judgment.

Technically correct code can still be contextually wrong. The agent may not know the business constraint behind a requirement or why the team chose a particular architecture three months ago. Supplying those reasons is part of directing the work, not an optional supplement to the coding request.

The Agent-Model Architecture slide has three boxes: You for direction and judgment, Agent running locally in the IDE, and Model running in the cloud. A warning below says models are stateless.Open full source frame
You provide direction and judgment; the agent and model have separate roles.

O’Leary attributes to Ronacher a gain of more than 30% of his day through machine assistance. The talk supplies no measurement method or task breakdown; it connects that reported gain to knowing what to delegate and what to retain. The valuable habit is selective delegation followed by direction and review, rather than automatic acceptance of suggestions.

2:573:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:57 · section reference included

Context can become a liability

This makes context engineering the first practical skill. O’Leary draws on Andrej Karpathy’s framing: fill the context window with what the agent needs for its next step. In a workflow that resends the conversation history, earlier material becomes input again on successive requests. Accumulating context therefore adds recurring token cost, not just a one-time expense when the material first enters the conversation.

O’Leary uses roughly 50% context-window occupancy as a warning point for declining quality, not a demonstrated model-independent threshold. His concern is that useful working space can disappear before you notice: enabled MCP servers, for example, can contribute tool information even when their capabilities are irrelevant to the task. The operational signal is to watch context consumption and output quality together.

Volume is only one problem. Unrelated tasks, outdated code comments, and abandoned decisions can all contaminate the working context. Suppose an agent has spent a long conversation pursuing the wrong approach. Correcting it does not remove that history. Earlier decisions remain available to influence later output, and rejected patterns can creep back into the implementation.

When repeated steering cannot get the work back on track, start a new session. The purpose is to stop carrying the failed path forward as part of every subsequent request. More context is useful only when it helps the next decision; beyond that, it can increase both cost and confusion.

4:284:49
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:28 · section reference included

Persist, select, compress, and isolate

Context management consists of four complementary operations:

  • Persist: Keep durable information outside the conversation in scratchpads, memory files, and AGENTS.md. The information remains available without requiring the entire exploration to stay in the active window.
  • Select: Bring in what the current step needs. Use file @ mentions deliberately, disable unnecessary MCP servers, and curate the data the agent receives.
  • Compress: Once a debugging investigation has established the problem and a proposed solution, summarize those findings. The implementation session needs the result of the investigation more than every turn taken along the way.
  • Isolate: Separate unrelated tasks into different sessions or agents so their contexts do not accumulate together. O’Leary connects this benefit to the recent rise of parallel-agent workflows.

These operations preserve useful knowledge while controlling what participates in the next request.

7:117:23
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:11 · section reference included

When a placeholder becomes a requirement

The same problem appears in ordinary engineering management. Early in his career, O’Leary managed engineers at a healthcare software company. The newly released iPad looked like a promising way to collect patient histories—the forms patients repeatedly fill out at a doctor’s office. He designed the proposed interface in Balsamiq, a wireframing tool whose deliberately rough presentation included Comic Sans and smiley-face placeholders.

He handed the wireframes to summer interns as a greenfield project. Weeks later, they returned a working prototype with Comic Sans and the placeholder graphics intact. They had implemented what the specification showed. O’Leary places responsibility on himself: he had not explained which details mattered, which were placeholders, or what problem the interface was meant to solve.

An agent handoff needs the same distinction between requirements and incidental material. O’Leary reduces the daily habit to a short procedure:

  1. Keep one task in each session and watch the context meter.
  2. If the work goes off track, ask the current agent to summarize it for a successor.
  3. Read that summary and correct anything that does not match your understanding.
  4. Start the new session with the checked summary.

The summary is itself a deliverable to review. Otherwise, restarting can simply transfer the same misunderstanding into a smaller context.

8:489:06
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:48 · section reference included

Why research comes before code

Of the workflows collected at Agentic Engineering for Humans, O’Leary repeatedly returns to research–plan–implement. It addresses a familiar mistake: asking an agent to implement a feature immediately, before either participant has established how it fits the existing system.

When he joined Kilo Code, he rejected the idea of a website demonstration consisting only of a prompt followed by code streaming past. That makes an impressive visual, but generation speed can hide incorrect assumptions. The resulting rework wastes time and can leave developers convinced the tools are unhelpful.

Experience can also become stale. O’Leary uses the early Will Smith eating spaghetti videos as a reminder of how quickly AI capabilities change. Coding agents deserve fresh evaluation too—but under conditions that give them a chance to succeed. First establish a shared understanding of the problem, then lay out explicit steps, and only then generate the implementation. His paraphrase of Dex Horthy’s warning is that a small mistake in research can expand into a large amount of bad code. Review effort belongs upstream, before that expansion occurs.

11:1911:29
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:19 · section reference included

Turn understanding into an executable plan

Begin research in a mode that cannot jump ahead into editing. In the talk, Kilo’s Ask mode chats and can read permitted files but cannot write them. That restriction keeps the immediate objective on understanding the system. Identify current behavior, relevant files, established patterns, differences from similar features, data flow, and edge cases. Use the agent’s breadth to brainstorm cases you may have missed.

The output is a research document that you read and agree reflects the problem. This is the first review gate. A fluent explanation is not sufficient; the document needs to match your understanding of the system before it becomes the foundation for a plan.

Next, make the proposed change explicit:

  1. Name the files to create or modify.
  2. Describe the steps and expected effects on the system.
  3. State what is in scope and what must remain unchanged.
  4. Identify the tests to add or change and the commands that will verify the result.
  5. Record the instructions in a plan file, often kept in a Plans directory.

Code snippets can help, but are optional; a plan need not prewrite the implementation. The planning slide also includes a rollback strategy, making reversal part of the preparation rather than an afterthought.

Phase 2: Plan slide pairs outlining exact steps, including testing, and being explicit with a Plan File containing instructions, specific code changes, test commands, and a rollback strategy.Open full source frame
A plan specifies changes, testing, scope, and a rollback strategy.

A sufficiently clear plan can make implementation suitable for a smaller, faster, or cheaper model. The reasoning has not disappeared: it has been concentrated in the research and planning phases, where a person can inspect it before many lines of code depend on it.

13:4513:57
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:45 · section reference included

Use Git as the first review

Start implementation in a fresh session with the reviewed plan as its execution context. This avoids dragging the whole research conversation into the coding phase. Review changes carefully and commit frequently, keeping each increment understandable.

O’Leary, who previously worked at GitLab, treats local Git review as his first pull-request review with the agent, before sending an actual PR to colleagues. A small command sequence makes that habit concrete:

bash

git status --short
git diff --stat
git diff
# After reviewing the changes, stage only the intended hunks.
git add -p
git diff --cached

The working-tree diff shows what changed; interactive staging selects the intended portions; the staged diff shows what the next commit will contain. Run the plan’s verification commands before committing.

The highest-leverage human work happens during research and planning. By implementation time, the difficult decisions should already be explicit. O’Leary returns to Horthy’s framing: AI amplifies the thinking you have done, including the consequences of not thinking something through. Faster implementation makes the quality of the earlier decisions more consequential.

16:1116:21
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:11 · section reference included

Configure roles, rules, and autonomy

Agent configuration can reinforce the workflow. O’Leary maps Ask to research, Architect to planning, and Code to implementation. Repository, workspace, or global rules then supply conventions that should hold across those roles. The agent cannot reliably follow project expectations that nobody has written down.

Decide separately how much work the agent may perform without interruption. Multiple agents may need worktrees so their changes can be merged locally before a PR. Approval settings should distinguish reading inside the workspace from reading outside it, and reading files from running tests or other tools. Start with permissions you understand and revisit them as experience reveals where intervention is useful.

Three configuration layers serve different purposes:

LayerPurposeTypical contents
ModesDefine the current roleResearch, planning, implementation
AGENTS.mdSupply recurring project guidanceConventions, build commands, test requirements
SkillsSupply a workflow when neededA reusable task playbook

Keep AGENTS.md focused on the minimum project knowledge an agent needs: how to build and test, which conventions to follow, and what to check before committing. Treat it as the agent’s project README rather than a store for every possible instruction.

Skills are better suited to recurring procedures such as making motion graphics with Remotion or compiling daily, weekly, or monthly changelogs. Their detailed instructions are brought in when the workflow is needed. O’Leary introduces the comparison using the name SKILLS.md; the Agent Skills specification uses the singular filename SKILL.md. The practical distinction is between compact standing instructions and task-specific playbooks.

17:3417:44
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

17:34 · section reference included

Make useful context easy to supply

Once the basic workflow is comfortable, interface shortcuts reduce the friction of maintaining it. O’Leary’s Kilo examples include:

  • Targeted references: Use @ mentions to bring in files, commits, and terminal output.
  • Session commands: Use slash commands to start a new task or condense a growing context.
  • Selected code: In VS Code, select a passage and use the right-click option to add it to Kilo Code, then ask questions or request a targeted edit.
  • Autocomplete: Use completions for prompts as well as code.

These are ways to supply precise working material without manually reconstructing it in every request.

The same collaboration is expanding beyond the IDE to the CLI, mobile access, cloud agents, and Slack. O’Leary sees this as a change in availability: the agent can participate where the work is being discussed or directed, rather than only while someone is sitting in an editor.

20:5721:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

20:57 · section reference included

Add the tools the task actually needs

Model Context Protocol, or MCP, provides a way to expose additional tools to an agent. A model’s token input and output can participate in a larger loop in which tool calls inspect or affect the environment, such as running tests. The GitHub MCP server extends that environment with access to pull requests, comments, and issues. Context7 supplies current framework documentation, addressing the gap between a model’s training cutoff and later library changes.

The benefit comes with a context-management decision. O’Leary warns that exposed tool descriptions can become recurring prompt input. The amount depends on the client and its tool-loading strategy; it is not an unavoidable upfront cost for every MCP implementation. Still, unused integrations deserve scrutiny. In his example, a Postgres MCP connection adds little during frontend-only work that does not involve the database. Its tool information consumes context and can also suggest a database operation where none belongs. Disable it for that task.

Internal platform APIs do not automatically require a custom MCP server. O’Leary offers four options, chosen according to the information and workflow involved:

Existing material or needIntegration approach
An API specification existsUse the OpenAPI or Swagger specification
Documentation needs a readable local formStore Markdown in the repository
Information changes frequentlyHave the agent retrieve a reference URL
A workflow spans multiple steps and systemsConsider a custom MCP server

Markdown can live in AGENTS.md or another referenced repository document. A live reference suits information that must be refreshed at use time. A custom server becomes useful when the agent needs coordinated actions across systems, rather than merely a description of an API.

22:4722:56
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

22:47 · section reference included

Keep the work reviewable, then get repetitions

Whatever tools supply the context, keep your changes separate from the agent’s work and review its contribution as a pull request. The closing technical slide contrasts editing conflicts with parallel work in Git worktrees. Separation makes the agent’s contribution identifiable, so you can inspect it with the same care you would give a junior engineer’s PR.

Working Alongside Kilo slide contrasts editing conflicts with CLI parallel mode using git worktrees, shows separate human and Kilo work locations, and highlights reviewing Kilo’s work as a separate PR.Open full source frame
Isolate your work from Kilo’s and review its changes as a separate PR.

O’Leary closes the product discussion with Kilo’s expansion across working surfaces and its then-stated focus on OpenClaw and KiloClaw, aiming to make OpenClaw agents safer to use. He invites feedback on Kilo rather than presenting a security design or deployment procedure. For readers following that product direction now, the KiloClaw documentation, checked August 28, 2026, marks the service as end of life, unavailable to new users, and approaching the end of support.

The final recommendation is to pick a tool and accumulate repetitions. Trust becomes calibrated through experience with what the model handles well and where it still needs your judgment. Try the research–plan–implement loop, review what happens, and adjust the next handoff. The reward O’Leary points toward is the renewed enjoyment some senior engineers report: delegating tedious work while spending more of their own attention on the harder engineering problems.

25:2225:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

25:22 · section reference included

Resources

From the talk

Updates since the talk

  • Current Kilo documentation for built-in agents and their tool permissions.

  • Retained documentation for Kilo's hosted OpenClaw service, now closed to new users with support ending.

Transcript download
Full transcript

Loading transcript…