Journal entry / AI / ML

Agentic RDE: Giving AI-Assisted Development a Durable Engineering Memory

Engineering field notes · Software Development / AI

One of the stranger problems with AI-assisted development is that the code can move faster than the project’s understanding of itself. A feature gets implemented, a useful architectural discussion happens in chat, and a week later another session has to rediscover why any of it was done that way. The code survived. The reasoning behind the decision is harder to find.

I kept running into this as my work moved between architectural conversations, repository implementation, and review. The handoff became its own engineering problem: what does the next person or agent need to know, what are they allowed to change, and what would actually prove the work is complete?

That is the problem behind the Agentic RDE Framework. RDE stands for Requirements-Driven Engineering. It is a reusable blueprint for organizing agent-assisted software work around requirements, evidence, explicit decisions, and accountable human review. I’m sharing it so other developers can inspect the approach and see where it fits their own repositories.

The repository has to remember

A conversation is a useful place to explore an idea. Once that idea becomes an accepted requirement or architectural decision, it needs a durable home. Otherwise every new session starts with an archaeological expedition through old messages, half-current diagrams, and comments that may or may not describe the system anymore.

In this model, the repository holds the accepted engineering context alongside the implementation: what the project is trying to accomplish, what currently exists, which decisions have been accepted, what work is ready, and what evidence supports completion. Tickets and conversations can link to those records. The next session has something concrete to read.

Engineering note / External memory still needs maintenance

Repository documents can act as durable project memory, but a Markdown file does not become true just because it is committed. Sources need clear status, named owners, and updates when behavior or decisions change. Otherwise persistent context becomes persistent confusion.

Start with what actually exists

The first step in an unfamiliar repository is discovery. Read its instructions, inventory the code and documentation, trace important flows, examine tests and delivery configuration, and record what remains unknown. Preserve existing material while establishing which claims can be supported.

The blueprint separates two questions that are easy to blur: What does the system do today? and What have we agreed it should do? Source, tests, and verified runtime behavior inform the first. Accepted requirements, contracts, and architecture decisions govern the second. A target architecture diagram cannot prove a migration has happened.

That distinction matters particularly during modernization, where old and new systems may coexist. Compatibility, data reconciliation, rollout, and rollback need explicit treatment. For greenfield projects, discovery instead starts with stakeholders, constraints, deployment assumptions, and the smallest useful end-to-end slice.

Make the decisions portable

An Architecture Decision Record, or ADR, captures a durable choice: its context, alternatives, consequences, and acceptance. It gives the next engineer a way to understand why an interface, boundary, or migration strategy looks the way it does. If the choice changes, a new record supersedes it while preserving the history.

The framework also includes templates for task briefs, project status, an implementation board, change control, readiness and completion criteria, and significant agent activity. These are meant to be adapted. If a repository already has a useful roadmap or decision system, keep it and fill the gaps.

Engineering note / A task needs an ending

A reviewable task names an outcome, its scope, the behavior to preserve, acceptance criteria, and the evidence required. That gives an agent a stopping point. Unrelated cleanup or a speculative redesign belongs in a separate task.

A practical example: changing an API safely

Consider a hypothetical application whose API is moving to a new response format while an older client still depends on the existing contract. A request to modernize the endpoint leaves several important questions open. Which clients must continue to work? Who accepts a breaking change? How will we detect a compatibility failure?

An RDE task would link to the current contract and the accepted migration decision. It would identify the files and behavior in scope, define compatibility expectations, and require evidence from producer and consumer contract tests. It would also describe rollout and rollback before implementation starts.

The agent can then implement a bounded change and report the exact checks it ran, what passed, what failed, and what it could not verify. A reviewer can compare the result against the requirement. A passing build helps, but it does not establish that an old client still works or that a production rollout is safe.

Authority belongs to the task

The blueprint describes observer, planner, implementer, reviewer, and release-operator roles. Their authority is explicit and scoped to the work. Permission to inspect a repository does not imply permission to deploy its application, and permission to implement a task does not transfer ownership of product or risk decisions.

It also treats engineering personas as optional review lenses. Looking at a change through security, data, operations, or frontend concerns can uncover missing questions. A persona label alone supplies neither independent review nor acceptance authority. Those still need real owners and evidence.

What is available today

The repository currently provides the standalone blueprint, an implementation guide, generic templates, and workflows for discovery, modernization, and greenfield work. The pattern grew from practical modernization work, including the PowerPunch project, and was extracted into a separate repository so its operating model could be examined independently of that application.

This is an initial extracted blueprint. It describes an operating model that can work across languages, platforms, and agent vendors. It does not ship a coding agent, enforce its own permissions, or replace an issue tracker, CI system, or engineering leadership. Repository instructions need to be backed by the permissions, review practices, and controls of the tools actually doing the work.

Dashboarding, drift detection, task synchronization, readiness checks, and evidence aggregation are future automation opportunities described in the blueprint. They are not delivered capabilities of this repository. There is also no benchmark here establishing a productivity gain; the approach needs to earn its place through reduced ambiguity, rework, and handoff cost.

Try it on one milestone

Start by reading the blueprint and choosing the adoption mode that fits your repository. Inventory the existing sources and preserve them. Establish a small source-of-authority map, a current status record, and the decisions that block useful work. Assign the humans who can accept those decisions.

Then define one small milestone and one task with measurable acceptance criteria. Use only the templates that protect a real decision or handoff. Follow that task through implementation, validation, review, and acceptance before expanding the process.

Engineering note / Measure the friction removed

After the first milestone, ask whether the records made it easier to resume work, find an accepted decision, verify completion, or catch an assumption before it became code. Remove duplicate records. Document count is a poor measure of engineering maturity.

Keeping engineering intent intact

What interests me most is the continuity: being able to pause a project, return with a different model or collaborator, and recover the requirements, constraints, decisions, and evidence without reconstructing the whole conversation. That is useful even when no agent is involved.

The Agentic RDE Framework repository is public on GitHub. If you explore it, I’m particularly interested in where the smallest useful scaffold ends and unnecessary process begins. The goal is to make a project easier to understand, change, and hand over as the work grows.

Filed under / AI / ML · Software Development

Leave a Reply