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:
| Stage | What the developer hands over | What comes back |
|---|---|---|
| Early 2020s: autocomplete | A partial line or function signature | A suggested continuation |
| 2022: copilots | A description of a function | A possible implementation |
| 2025 onward: agents | A task | File 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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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:
- Keep one task in each session and watch the context meter.
- If the work goes off track, ask the current agent to summarize it for a successor.
- Read that summary and correct anything that does not match your understanding.
- 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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:
- Name the files to create or modify.
- Describe the steps and expected effects on the system.
- State what is in scope and what must remain unchanged.
- Identify the tests to add or change and the commands that will verify the result.
- Record the instructions in a plan file, often kept in a
Plansdirectory.
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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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:
| Layer | Purpose | Typical contents |
|---|---|---|
| Modes | Define the current role | Research, planning, implementation |
AGENTS.md | Supply recurring project guidance | Conventions, build commands, test requirements |
| Skills | Supply a workflow when needed | A 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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 need | Integration approach |
|---|---|
| An API specification exists | Use the OpenAPI or Swagger specification |
| Documentation needs a readable local form | Store Markdown in the repository |
| Information changes frequently | Have the agent retrieve a reference URL |
| A workflow spans multiple steps and systems | Consider 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Practical guides to task decomposition, agent workflows, validation, and team adoption.
The project instruction-file convention for sharing commands and repository guidance with coding agents.
GitHub's official MCP integration for repository, issue, and pull-request workflows.
Retrieves current library documentation and code examples for coding assistants.
Further reading
Dex Horthy explains intentional compaction and research–plan–implement using concrete codebase examples.
Defines SKILL.md, skill directories, metadata, and on-demand loading of workflow instructions.
Explains tool discovery and deferred loading for keeping large tool libraries out of the initial context.
- Google's 2025 DORA findingsArticle
Survey findings on AI adoption, usage, and trust among nearly 5,000 technology professionals.
Updates since the talk
Current Kilo documentation for built-in agents and their tool permissions.
- KiloClaw end-of-life noticeDocumentation
Retained documentation for Kilo's hosted OpenClaw service, now closed to new users with support ending.
Full transcript
Loading transcript…