Holmes LabAgentic Software Engineering Architect

Engineering perspective

I design how
software evolves.

From shared ultrasound platforms to agentic development, I connect architecture, how teams work and the evidence behind each change.

From products to a shared foundation

One strategy, across product boundaries.

One Branch was more than a source-control choice. I connected code, product variation, UX and hardware design so a platform could become a repeatable basis for delivery.

Different specificationsDifferent launch datesDifferent hardware

Shared platform strategy

SPLE × One Branch

Feature Configuration
Explicit product variation
One UX
A consistent product experience
H/W superset → variants
A shared basis for hardware control
HS60product family
V8product family
Z20product family
A conceptual map of the strategy I led; not a diagram of internal product architecture.

The situation

When each product copies code and follows its own specifications and schedule, a problem solved once can return elsewhere.

Design for the next product family.

I established a shared SPLE platform and One Branch as a development strategy. Product differences needed explicit design just as much as common capabilities needed reuse.

How I put it into practice

I began implementing Feature Configuration in 2013 and led the integration of variant changes into a shared base. Commercial delivery expanded the platform across the HS60, V8 and Z20 product families.

What I carry into AI engineeringWith AI-generated changes, I ask about shared foundations and affected consumers before treating a single file as complete.

The situation

Combining software alone leaves growing exceptions when UX and hardware-control designs still diverge by product.

Shared code needs shared product boundaries.

I planned UX unification within the One Branch strategy. From the software hardware-control perspective, hardware design also needed to support the shared platform.

How I put it into practice

I extended the approach into One UX in 2018 and led its application in commercial products. I also led the transition from fragmented hardware designs toward an integrated superset with product-specific variants.

What I carry into AI engineeringThis is why I connect agent roles, permissions, tools and verification as one development system.

The situation

Product-specific targets and schedules did not naturally align with platform development. Efficiency and feasibility of One Branch were also challenged.

A strategy must survive conflicting delivery schedules.

I took responsibility for advancing the shared foundation alongside individual releases, connecting architecture to development projects and organizational execution.

How I put it into practice

I introduced and led Agile practice in the workplace. With my colleagues, I carried One Branch through to commercial delivery, extending accumulated technology across products and contributing to development efficiency and company growth.

What I carry into AI engineeringDividing AI work is not enough. Teams need a shared basis for integration and evidence of completion.

Explore my platform and leadership journey ↗

From shared code to shared evidence

Give agents a basis for judgment.

Fast implementation is one part of the workflow. My focus is connecting why a change is needed, where its impact reaches and how its result can be checked.

RTMTrace intent → implementation; trace results → requirements
  1. 01

    Requirement

    What must change?

    Intent and acceptance criteria
  2. 02

    Design

    Why this approach?

    Decisions, scope and constraints
  3. 03

    Code

    What else is affected?

    Anchors, callers and dependencies
  4. 04

    Verification

    What actually works?

    Failure cases, regressions and runtime checks
CPG

Investigate the code behind the trace

AST Structure
Which symbols and syntax form this implementation?
CFG Control flow
Which branches and execution paths can run?
PDG Dependencies
Which data and control dependencies carry the impact?
Agent workflow

Read the requirement → investigate related code → make a scoped change → check evidence and report gaps

Conceptual workflow. Available analysis depends on language, extraction coverage and data freshness. Explore the actual project records below.

The situation

When a request goes straight to implementation, its acceptance conditions and design rationale can become buried in the code.

Connect the reason for a change before writing code.

In Holmes-Kit, RTM connects requirements, high-level design, implementation design and tests. Specification anchors connect code back to intent.

How I apply this

In Holmes Lab, I use approved specifications to define implementation scope and link verification cases. Agents inspect the requirement and relevant design before a change, then record the results of the associated tests.

The principleTraceability is the ability to answer “what is this change for?” again, without reconstructing the entire conversation.

The situation

Knowing which function to edit does not reveal every caller, control-flow path or data dependency that needs verification.

Finding connections is not proof of safety.

I use RTM to establish purpose and CPG information—AST, CFG and PDG—to investigate structure, execution paths and dependencies. Unresolved relationships must inform the verification plan too.

How I apply this

Agents gather related code and candidate tests, then choose failure cases and regressions against the actual requirement. I distinguish passing tests, a successful build and observed production behavior. Analysis coverage and snapshot freshness are part of that judgment.

The principleA graph supplies evidence to investigate. It does not establish complete impact coverage or verified runtime behavior by itself.

The situation

An agent reporting completion is different from the intended work actually being complete within its authorized scope.

Autonomy needs execution boundaries and observable outcomes.

I design intent, permissions and completion criteria together. Reversible development and external publication or operational changes need boundaries proportionate to their impact.

How I apply this

Holmes-Kit addresses specifications and verification; Jarvis explores agent roles and execution policies; Holmes Lab connects a public experience to deployment checks. They are three settings in which I put this perspective into practice.

The principleMy direction for Agentic Software Engineering is a system that can understand, verify and operate change responsibly.

Put this into practice: Holmes-Kit Guide ↗

See the perspective at work.

These are independent projects where I implement and examine the approach. Follow the records, not just the description.

Holmes-Kit Specifications, traceability and verificationJarvis Agent roles and execution policiesHolmes Lab Public experience and deployment evidence