Skip to main content
LeoNex News

Beyond code generation: an "agentic engineering" guide for developers

Illustration: Beyond code generation: an "agentic engineering" guide for developers
In this article

Context: more code, but slower review

A developer's work includes gathering requirements and steering implementation, reviewing changes and evaluating test results, then investigating what happens in production. The four stages Plan, Build, Verify, Observe cover this entire chain.

Plan: getting everyone and every agent pointed in the same direction

  • Plan right inside the tools your team already uses: Copilot in Slack or Teams helps you collaborate with product managers, designers, analysts and other stakeholders, while bringing in context from connected tools to check assumptions and refine requirements.

  • Turn agreed requirements into concrete work: ask Copilot to create GitHub Issues with context and acceptance criteria, broken down into tasks that can be handled separately.

  • Reduce the everyday triage burden: GitHub Agentic Workflows labels issues and estimates complexity, and simple work is assigned straight to Copilot so developers can focus on harder decisions.

  • For complex work, use Plan Mode to compare options and refine the plan; the plan is reviewed and approved before Copilot is handed the work to begin implementation.

The result is that instead of spending days searching for and gathering context, developers have a plan they can review, clear acceptance criteria and issues with a limited scope, and their time goes to decisions rather than information retrieval.

Build: driving multiple tasks at once

Once you are ready to turn the plan into code, other things creep in: an agent is partway through a task, a meeting is about to start, and someone points out an edge case that needs handling. The goal is to keep work moving without being tied to the machine where the session started.

As a result, tasks progress independently of shared project knowledge, and when the work is done, developers have focused changes ready for review.

Verify: focusing attention where it matters

Smaller changes, with routine work already handled, reduce the number of back-and-forth rounds, so reviewers can spend their attention on whether the code does what was intended and what could go wrong.

Observe: learning from what happens after shipping

The change has been approved and all the deployment checks pass, but the next morning the on-call dashboard reports intermittent timeouts and some large customers are affected. Now you have to cross-reference logs, release history and customer reports, while the question of whether to roll back is on the table. You need to combine operational evidence with technical context to decide.

  • Check assumptions against real behavior: with access to observability tools and business data through connectors such as Fabric, Copilot helps investigate which requests or groups of customers are affected.

  • Record findings where they can be acted on: ask Copilot to draft an issue with evidence and acceptance criteria, including a regression test for the bug just found.

  • Carry lessons into later work: review the improvement suggestions from Dreaming, which uses sessions and activity in the repository to refine memory, skills and code review guidelines.

This way, more time goes to the decisions that need to change things and less to retracing the investigation, and the next plan starts from what was learned from software that real users are actually using.

Where to start

You can pick a piece of work you already have and look beyond the coding task: what context it needs, how it will be reviewed and tested, and how you will know it works well after shipping. There is no need to change the whole process at once: start with whatever is most frustrating this week, hand it to an agent, then expand gradually to other parts.

Key takeaways

More in AI Engineering

Illustration: Context engineering and guardrails to "tame" coding agents
AI-ENG AI Engineering

Context engineering and guardrails to "tame" coding agents

Coding agents such as Cursor, Windsurf, Cline or Claude Code often deliver impressive results early on, but as a project grows with many files and branching business logic, they can break working features, pull in conflicting libraries or violate the architecture. The cause lies in an unstructured way of using them…

4 min read

Email newsletter

Receive a selection of new LeoNex News articles by email.

We only use this address to send the newsletter.

Receive a selection of new LeoNex News articles by email. You will receive a confirmation email; the subscription only takes effect after you confirm. Every email includes an unsubscribe link. Read the privacy policy