A professional foundation in medical software. A personal practice in agentic engineering. Different contexts, connected by the work of building reliable systems.
Architecture you can inspect
Follow the connections, then inspect the actual tool captures.
Open a case, playing automatically at 2×. Follow the problem, its actual evidence and the next investigation on one steady stage.
Read the three-project transcript
Actual public relationships with an illustrated agent workflow. Structural connections do not prove execution, approval or complete impact.
Holmes-Kit · What evidence supports the change-analysis tool?
0:00 · Start with a real engineering problem
Suppose change analysis misses relevant code. Investigate the analyzer itself. Agent: Identify the engineering question.
Where should an agent start when changing the analysis tool? Agent: Locate the existing intention.
Change analysis gathers code and specification candidates related to a request. Agent: Keep the walkthrough separate from execution evidence.
0:15 · Locate the original requirement
A requirement records the intention behind the work. Agent: Read the requirement reference.
The case starts at REQ-267. Agent: Compare the requested change with its intent.
Changing code starts with understanding what must remain true. Agent: Record what still needs clarification.
0:30 · Follow the high-level design
The high-level design depends on this requirement. Agent: Find the actual dependency.
We follow the stored link back from the requirement. Agent: Collect the associated design.
The arrow still points toward the dependency, not the order of execution. Agent: Preserve the original relationship direction.
0:45 · Find the applicable implementation design
A-SPEC-267 is the implementation design selected for this case. Agent: Identify the applicable detailed design.
It connects through the high-level design to the original intention. Agent: Keep the selected lineage in scope.
Another design under the same requirement is not automatically the same scope. Agent: Do not borrow evidence from a sibling design.
1:00 · Locate the declared implementation
analyzeMaintenance has a declared implementation association. Agent: Locate analyzeMaintenance.
The current implementation finds candidates from the request, code and specs, then uses supplied history to rerank. Agent: Inspect its implementation context.
A file anchor does not prove that one function satisfies the requirement. Agent: Treat the anchor as a lead, not proof of correctness.
1:15 · Look inside the control flow
Zoom into an available current-source control-flow view. Agent: Open the available CFG.
The highlighted relationship is a possible transition between blocks. Agent: Inspect the highlighted branch.
A static branch is not a record that this path actually ran. Agent: Plan checks for the relevant alternatives.
1:30 · Separate data and control dependence
Control dependence and data dependence answer different questions. Agent: Inspect the available dependence layer.
Use only relationships actually present in the analysis. Agent: Identify what needs deeper investigation.
No AST tree, variable values or private source text is reconstructed here. Agent: Do not infer unpublished variable semantics.
1:45 · Assemble evidence for the agent
The agent can gather the requirement, design and relevant code. Agent: Collect the verified references.
It can use this bounded context to plan the next investigation. Agent: Use a bounded context for the next task.
This illustrates evidence use; it does not expose or replay internal reasoning. Agent: Mark uncertain or missing evidence explicitly.
2:00 · Find what needs verification
A linked T-SPEC identifies verification intent. Agent: Find the same-design test specification.
Missing related code and verification targets still need investigation. Agent: Prepare verification targets.
An existing test specification is not evidence that tests passed. Agent: Request actual execution results before declaring success.
2:15 · Check the conditions before acting
Before editing, the agent must check the applicable work conditions. Agent: Check current specification and policy conditions.
Approval, scope and required evidence depend on the active policy. Agent: Use the official approval or remediation path if required.
These policy steps are explained here; no historical approval is asserted. Agent: Proceed only within the permitted scope.
2:30 · Separate evidence from missing proof
The public snapshot provides structural relationships. Agent: Check snapshot and analysis provenance.
Its equality with a particular historical source revision is unverified. Agent: Request missing version or execution evidence.
Matching execution and approval receipts are not available in this film. Agent: Leave unverified claims unverified.
2:45 · Continue the investigation yourself
Without these links, the agent must separately locate the original intent and applicable verification. Agent: Keep the requirement-to-code trail.
RTM connects that investigation: requirement, design, implementation and verification intent. Agent: Open the real evidence for inspection.
Inspect the same evidence yourself before deciding what to change. Agent: Continue with a reviewable change and verification plan.
Holmes Lab · Where do the relationships on this page come from?
0:00 · Start with a real engineering problem
Suppose we extend relationship traversal by one hop. What needs checking? Agent: Identify the engineering question.
What evidence should accompany a change to relationship traversal? Agent: Locate the existing intention.
Relationship traversal determines which neighbors to inspect from a starting node. Agent: Keep the walkthrough separate from execution evidence.
0:15 · Locate the original requirement
A requirement records the intention behind the work. Agent: Read the requirement reference.
The case starts at REQ-101. Agent: Compare the requested change with its intent.
Changing code starts with understanding what must remain true. Agent: Record what still needs clarification.
0:30 · Follow the high-level design
The high-level design depends on this requirement. Agent: Find the actual dependency.
We follow the stored link back from the requirement. Agent: Collect the associated design.
The arrow still points toward the dependency, not the order of execution. Agent: Preserve the original relationship direction.
0:45 · Find the applicable implementation design
A-SPEC-101.9 is the implementation design selected for this case. Agent: Identify the applicable detailed design.
It connects through the high-level design to the original intention. Agent: Keep the selected lineage in scope.
Another design under the same requirement is not automatically the same scope. Agent: Do not borrow evidence from a sibling design.
1:00 · Locate the declared implementation
reachable has a declared implementation association. Agent: Locate reachable.
This function traverses neighbors in both directions, bounded by allowed IDs, depth and previously visited nodes. Agent: Inspect its implementation context.
A file anchor does not prove that one function satisfies the requirement. Agent: Treat the anchor as a lead, not proof of correctness.
1:15 · Look inside the control flow
Zoom into an available current-source control-flow view. Agent: Open the available CFG.
The highlighted relationship is a possible transition between blocks. Agent: Inspect the highlighted branch.
A static branch is not a record that this path actually ran. Agent: Plan checks for the relevant alternatives.
1:30 · Separate data and control dependence
Control dependence and data dependence answer different questions. Agent: Inspect the available dependence layer.
Use only relationships actually present in the analysis. Agent: Identify what needs deeper investigation.
No AST tree, variable values or private source text is reconstructed here. Agent: Do not infer unpublished variable semantics.
1:45 · Assemble evidence for the agent
The agent can gather the requirement, design and relevant code. Agent: Collect the verified references.
It can use this bounded context to plan the next investigation. Agent: Use a bounded context for the next task.
This illustrates evidence use; it does not expose or replay internal reasoning. Agent: Mark uncertain or missing evidence explicitly.
2:00 · Find what needs verification
A linked T-SPEC identifies verification intent. Agent: Find the same-design test specification.
Investigate depth zero, cycles and nodes outside the allowed set. These are checks to plan, not passed tests. Agent: Prepare verification targets.
An existing test specification is not evidence that tests passed. Agent: Request actual execution results before declaring success.
2:15 · Check the conditions before acting
Before editing, the agent must check the applicable work conditions. Agent: Check current specification and policy conditions.
Approval, scope and required evidence depend on the active policy. Agent: Use the official approval or remediation path if required.
These policy steps are explained here; no historical approval is asserted. Agent: Proceed only within the permitted scope.
2:30 · Separate evidence from missing proof
The public snapshot provides structural relationships. Agent: Check snapshot and analysis provenance.
Its equality with a particular historical source revision is unverified. Agent: Request missing version or execution evidence.
Matching execution and approval receipts are not available in this film. Agent: Leave unverified claims unverified.
2:45 · Continue the investigation yourself
Without these links, the agent must separately locate the original intent and applicable verification. Agent: Keep the requirement-to-code trail.
RTM connects that investigation: requirement, design, implementation and verification intent. Agent: Open the real evidence for inspection.
Inspect the same evidence yourself before deciding what to change. Agent: Continue with a reviewable change and verification plan.
Jarvis · What should be checked when an agent’s task policy changes?
0:00 · Start with a real engineering problem
Suppose we change the AI query path for one task. How do we preserve existing behavior? Agent: Identify the engineering question.
Which implementation and verification records relate to a task-policy change? Agent: Locate the existing intention.
Different task classes can select different query paths. Agent: Keep the walkthrough separate from execution evidence.
0:15 · Locate the original requirement
A requirement records the intention behind the work. Agent: Read the requirement reference.
The case starts at REQ-895. Agent: Compare the requested change with its intent.
Changing code starts with understanding what must remain true. Agent: Record what still needs clarification.
0:30 · Follow the high-level design
The high-level design depends on this requirement. Agent: Find the actual dependency.
We follow the stored link back from the requirement. Agent: Collect the associated design.
The arrow still points toward the dependency, not the order of execution. Agent: Preserve the original relationship direction.
0:45 · Find the applicable implementation design
A-SPEC-895 is the implementation design selected for this case. Agent: Identify the applicable detailed design.
It connects through the high-level design to the original intention. Agent: Keep the selected lineage in scope.
Another design under the same requirement is not automatically the same scope. Agent: Do not borrow evidence from a sibling design.
1:00 · Locate the declared implementation
query_for has a declared implementation association. Agent: Locate query_for.
The current implementation selects a query by task class; remaining cases return the original query function. Agent: Inspect its implementation context.
A file anchor does not prove that one function satisfies the requirement. Agent: Treat the anchor as a lead, not proof of correctness.
1:15 · Look inside the control flow
Zoom into an available current-source control-flow view. Agent: Open the available CFG.
The highlighted relationship is a possible transition between blocks. Agent: Inspect the highlighted branch.
A static branch is not a record that this path actually ran. Agent: Plan checks for the relevant alternatives.
1:30 · Separate data and control dependence
Control dependence and data dependence answer different questions. Agent: Inspect the available dependence layer.
Use only relationships actually present in the analysis. Agent: Identify what needs deeper investigation.
No AST tree, variable values or private source text is reconstructed here. Agent: Do not infer unpublished variable semantics.
1:45 · Assemble evidence for the agent
The agent can gather the requirement, design and relevant code. Agent: Collect the verified references.
It can use this bounded context to plan the next investigation. Agent: Use a bounded context for the next task.
This illustrates evidence use; it does not expose or replay internal reasoning. Agent: Mark uncertain or missing evidence explicitly.
2:00 · Find what needs verification
A linked T-SPEC identifies verification intent. Agent: Find the same-design test specification.
Investigate new-path selection, retention of the existing path and the separate extraction case. Agent: Prepare verification targets.
An existing test specification is not evidence that tests passed. Agent: Request actual execution results before declaring success.
2:15 · Check the conditions before acting
Before editing, the agent must check the applicable work conditions. Agent: Check current specification and policy conditions.
Approval, scope and required evidence depend on the active policy. Agent: Use the official approval or remediation path if required.
These policy steps are explained here; no historical approval is asserted. Agent: Proceed only within the permitted scope.
2:30 · Separate evidence from missing proof
The public snapshot provides structural relationships. Agent: Check snapshot and analysis provenance.
Its equality with a particular historical source revision is unverified. Agent: Request missing version or execution evidence.
Matching execution and approval receipts are not available in this film. Agent: Leave unverified claims unverified.
2:45 · Continue the investigation yourself
Without these links, the agent must separately locate the original intent and applicable verification. Agent: Keep the requirement-to-code trail.
RTM connects that investigation: requirement, design, implementation and verification intent. Agent: Open the real evidence for inspection.
Inspect the same evidence yourself before deciding what to change. Agent: Continue with a reviewable change and verification plan.
TRACEABILITY / INTERACTIVE EXPLORATION
Follow the engineering evidence.
Explore real requirements, designs and code across three projects.
Holmes-Kit · Static relationship example
Traceability inside the change-analysis tool
Example extracted: 2026-10-31T04:09:03.823678+00:00
I moved from imaging control and hardware interfaces to shaping software strategy across ultrasound product families. From H60/PT60A system architecture, I went on to lead SPLE platform development, One Branch and UX unification across the HS60 and V8 families and Z20/R20, connecting development projects and teams to commercial delivery.
Holmes-Kit, Jarvis and Holmes Lab are personal projects. They do not represent my employer’s products or official position.
ENGINEERING HARNESS
Holmes-Kit
From requirements to code impact, connected by evidence.
The problem — Faster code generation does not remove the need to explain a change or keep it within scope. Longer tasks increase the distance between initial intent and implementation.
My direction — I am building toward an Agentic Software Engineering Harness that combines precise requirements–design–code–test traceability with Code Property Graph (CPG) analysis. Specification links explain why a change exists; code structure and flow analysis inform change impact; test execution evidence records what was verified.
Three questions for every change — What requirement does it satisfy? What does it affect? What evidence verifies it? I aim for bidirectional traceability: follow a requirement to code and tests, then trace a code change back to affected requirements and verification gaps. A CPG alone does not establish requirement links. Their accuracy and freshness, and unresolved analysis relationships, matter too.
People and agents — People decide the problem, authority and acceptance criteria. Agents carry out tests and implementation tied to specifications. Automated checks and human review serve different purposes.
My practice here — I connect Holmes Lab’s requirements, design, implementation and test specifications, and record tests around changes. Tool binding, hook configuration and observed execution are treated as separate evidence.
Evidence & limits: My ambition is world-class traceability and change impact analysis. Progress must be evaluated through missed impacts, false positives, link accuracy and freshness, and verification results from actual agent work. Independent benchmarks and current execution transcripts are not published here. This introduction does not guarantee that all errors are blocked or that enforcement is active in every environment.
PERSONAL & FAMILY AI
Jarvis
Useful everyday AI — and the conditions for trusting it.
The problem — A personal and family assistant needs more than good answers. What it remembers, which actions it may take and how outcomes are verified are part of the product.
My decision — I keep the personal/family assistant separate from the public portfolio and retain the local Mac Studio operating direction. Family conversations, memory and tools are not shared with the public website.
What I verify — I distinguish understanding a request, calling a tool and achieving an outcome. Questions raised by operation feed back into permission boundaries and verification criteria.
What I share — I explain the purpose and architectural decisions behind the project. Family conversations and operational logs are not demonstration material. Project conversations continue on LinkedIn.
JARVIS / REAL-TIME VOICE & CHARACTER
Jarvis: real-time voice and character demo
Ask about AI coding. Watch Jarvis listen, think and speak through its animated character.
Conversation topic: Holmes-Kit. The recording demonstrates Jarvis’s voice conversation and character responses.
Prepared with public Holmes-Kit references. Questions use synthetic speech; answers are actual Jarvis real-time responses. Waiting intervals were shortened and volume balanced. This is a recording, not a live connection to the personal assistant.
Specifications and test evidence reduce risk; they do not guarantee error-free software or require human approval for every edit.
Actual recorded character and voice responses · EnglishRead the conversation
Question When I ask AI to write code, I worry it might change things I never asked for. How can Holmes Kit help? Answer in English in two short sentences, without personal names or memories.
Jarvis It keeps development within approved specifications, which reduces the chance of unrelated changes. It also links requirements to test evidence, making modifications easier to review and verify.
Question If AI says the tests passed, should I just trust it? Why do actual execution results and evidence linked to requirements matter?
Jarvis No. “Tests passed” alone isn’t enough to trust the system. Evidence linked to requirements and real execution results shows it behaves as intended and supports confident validation.
Evidence & limits: This page is not an evaluation of every assistant capability. Public-web notification integration, latency and reliability measurements are not claimed as complete in this case.
THIS SITE · IN DEVELOPMENT
Holmes Lab
A place to understand the work and start a thoughtful conversation.
The problem I want to solve — A list of roles and projects rarely explains the decisions I have made. Visitors need context, evidence and limits before a natural path to conversation.
My approach — I use bilingual static content to share my engineering journey, product platforms and personal projects. Contact continues on LinkedIn.
What I focus on — Clear writing, visual explanations and inspectable evidence. Accessibility, mobile readability and consistent color and typography are part of the product.
What I verify — I check bilingual builds, content and responsive views in a real browser. Local verification and public service operation are different levels of evidence.
Evidence & limits: I build, publish and continue to develop this site. I record local checks and deployment verification separately, and assess accessibility and performance in the public environment.
Below: explanatory architecture diagrams and static tool captures. Use the interactive explorer above to inspect persisted GraphDB relationships.
ENGINEERING / CONNECT THE EVIDENCE
See the structure. Follow the reasoning.
A change is more than a file. Explore how intent, implementation and verification connect—and where the evidence ends.
Which specifications and implementations connect to simplifying contact?
6 nodes / 5 links
Select a node to highlight its direct connections. Lines indicate relationships, not a measured execution sequence.
Professional hub — REQ-101 · Bilingual career-led public hub requirement.
Public experience — H-SPEC-101 · Functional design declaring REQ-101 as its parent.
Direct contact — A-SPEC-101.5 · Replaces email verification with direct LinkedIn contact.
Acceptance cases — T-SPEC-101.5 · Defines direct-contact and legacy-route acceptance.
Contact page — contact.astro · Static page with an A-SPEC-101.5 implementation anchor.
Contact tests — simple-contact.test.ts · Tests anchored to the same spec. A link alone does not prove a passing execution.
Inspect the relationships and sources
Professional hub → Public experienceRefines requirement.ax/specs/02_h-spec/functional/H-SPEC-101.md
Public experience → Direct contactDesign refinement.ax/specs/03_a-spec/A-SPEC-101.5.md
Direct contact → Acceptance casesDeclares acceptance.ax/specs/05_t-spec/T-SPEC-101.5.md
Direct contact → Contact pageImplementation anchorsrc/pages/[lang]/contact.astro
Direct contact → Contact testsTest anchortests/simple-contact.test.ts
2026-10-31 · Selected local spec dependencies and source @implements anchors. Not a full GraphDB export or an automated impact result. A relationship is not proof of test execution or completeness.
Connecting the reason, impact and verification of a code change.
6 nodes / 6 links
Select a node to highlight its direct connections. Lines indicate relationships, not a measured execution sequence.
Requirements — Purpose and acceptance of a change.
Design specs — Explicit implementation decisions.
Code structure — Code relationships analyzed through CPG, with scope and unresolved gaps.
Change impact — Reviewing change candidates and their impact.
Agent work — Implementation within an agreed scope.
Verification — Results assessed through tests and execution records.
2026-10-31 · Conceptual view based on the public project description; distinct from the native tool capture below. A relationship is not proof of test execution or completeness.
Separating request understanding, permission to act and outcome verification.
6 nodes / 6 links
Select a node to highlight its direct connections. Lines indicate relationships, not a measured execution sequence.
Request — The outcome the user wants.
Context — Responsibility for understanding relevant context.
Permission — Determining the permitted scope of action.
Tool execution — Carrying out permitted work.
Outcome check — Distinguishing a successful call from achieving the goal.
Feedback — Feeding operational lessons into design.
Inspect the relationships and sources
Request → ContextInterprets
Context → PermissionAssesses action
Permission → Tool executionConstrains
Tool execution → Outcome checkChecks outcome
Outcome check → FeedbackInforms
Feedback → ContextRefines design
2026-10-31 · Conceptual public architecture. No operational graph, personal memory or family conversations are included. A relationship is not proof of test execution or completeness.
THREE SYSTEMS / ONE ENGINEERING PRACTICE
Three workspaces. Three architectural perspectives.
Real captures from Holmes-Kit’s built-in graph tool. Each view has a different focus: evidence for change, a governed public product, and operating policy for agents.
Holmes-Kit
From the reason for change to evidence of impact.
DESIGN LENS · CONCEPTUAL SUMMARY
INTENTWhat changes?→
DECISIONWhat connects?→
EVIDENCEWhat verifies it?
Traceability ≠ impact-analysis accuracy
Open original ↗ACTUAL TOOL CAPTURE Holmes-Kit · REQ-267 · Radial · 3 hops · cap 30
WHAT TO NOTICE
An actual view centered on the maintenance-analysis requirement. Blue implementation links and orange function-call links answer different engineering questions.
Design tradeoff & transferable lesson
Broad discovery ↔ precise review candidates
A graph supplies evidence for judgment. Missed impacts, false positives and unresolved relationships must remain visible so reviewers can assess its limits.
2026-10-31 · Holmes-Kit 0.39.0 · Shown: 30 nodes · 97 edges. The scan includes both source and generated dist-tools symbols.
Holmes Lab
Put the engineering principles into a public product.
DESIGN LENS · CONCEPTUAL SUMMARY
INTENTComplex public features→
DECISIONSimplify the public experience→
EVIDENCEVerify, then publish
Operational completeness over feature count
Open original ↗ACTUAL TOOL CAPTURE Holmes Lab · REQ-101 · Pipeline · 3 hops · cap 30
WHAT TO NOTICE
Six columns separate requirements, design, test specifications, files and functions. Read across to see one requirement branch into designs and connect to implementation.
Design tradeoff & transferable lesson
Richer interaction ↔ operating cost and reliability
Email verification, guestbook and AI-guide interfaces were withdrawn in favor of direct contact and static hosting. Historical specifications in the graph are not a list of currently active features.
2026-10-31 · Holmes-Kit 0.39.0 · Shown: 30 nodes · 53 edges. A bounded view that includes historical specifications and implementations.
Jarvis
Design the conditions under which agents act.
DESIGN LENS · CONCEPTUAL SUMMARY
INTENTTask class→
DECISIONEngine · budget · deadline→
EVIDENCECheck the outcome
Tool-call success ≠ user-goal completion
Open original ↗ACTUAL TOOL CAPTURE Jarvis · REQ-895 · Pipeline · 3 hops · cap 30
WHAT TO NOTICE
Actual relationships around task policy, deadlines and retry budgets. The view exposes both design decomposition and code linked to multiple design specifications.
Design tradeoff & transferable lesson
Autonomous execution ↔ cost, time and failure control
Operating policy is an explicit design concern rather than solely a model judgment. This view shows design/code links; it does not prove execution success rates or policy compliance.
2026-10-31 · Holmes-Kit 0.39.0 · Shown: 30 nodes · 116 edges. Only software specification/code metadata is captured; no personal conversations or memory.
Authentic static captures; no graph data or labels were fabricated. Focused subsets, not whole-database views. The tool’s percentages describe its own approval/linkage criteria—not test pass rates, analysis accuracy or product quality. The visual summaries above are editorial guides, not measured execution traces.