Agentic Product & Software Development
I use agents in two places: inside the product and in the work on the product. From signals and triage through decisions, architecture, and implementation to operations and learning, this creates a faster system without handing accountability to a model.
How I see it
Software does not become faster only because agents write more code. The real step change happens when signals, decisions, implementation, operations, and learning work as one agentic flow.
Two changes, one system
My path into AI builds on my Cognitive Informatics studies: machine learning, multi-agent systems, robotics, and the question of how systems perceive, decide, and fail. That gives me judgment around architecture limits, model limits, and realistic use cases.
I use agents for product clarification, research, architecture, code, tests, review, documentation, and operations. At the same time, I build products where agentic capabilities become part of the user value. Both need the same care around context, boundaries, and feedback.
I treat PCA, k-means, Random Forest, NLP, Location Absorption Score, scoring logic, feature ablation, and target residualization as evidence tools in a product context: clarify data quality, target definition, baseline, stability, and explainability before making stronger model claims.
Agentic work becomes reproducible when context is cut cleanly, rules are explicit, permissions are clear, and reusable skills and tools exist. Corrections from tests, reviews, and operations return as reviewable changes to rules, tests, documentation, or runbooks.
I use AI where legibility, traceability, and accountability stay intact. Sources, decision paths, and model boundaries therefore remain part of the system.
Accountability stays human
The agentic value flow
AI helps sort customer, support, market, and operational signals, while decisions stay source-bound and reviewable.
Ambiguity becomes reviewable problem frames, risks, investment boundaries, and next slices instead of automatically generated ticket volume.
Reviews, tests, DevSecOps, observability, and rollout decisions move with the work instead of becoming a downstream control lane.
When errors, new evidence, or operational signals appear, they become reviewable artifacts, rules, and skills for the next loop.
Autonomy grows with evidence
I increase autonomy where the workflow is understood, boundaries are testable, and feedback from tests, reviews, and operations returns reliably. People remain responsible for direction, policies, and exceptions.
01 · Human-in-the-loop
Bets, critical architecture paths, high-risk changes, and releases remain explicit decision points.
02 · Human-on-the-loop
Review sampling, quality boundaries, and explicit escalation replace approval of every individual step.
03 · Exception-led
Uncertainty, new risk classes, and conflicting signals bring human judgment back in deliberately.
04 · Policy-governed
Access, budgets, quality boundaries, rollbacks, and audit trails keep the system legible and governable.
Practice and direction
At Livable Places, I connect multi-agent research, local agent skills, and plugin-style workflows with product clarification, data and ML evidence, code, tests, delivery, and platform operations. Corrections do not disappear into chat. They become reviewable artifacts and better project context.
From that practice, I keep evolving my working model for an end-to-end agentic value flow. It grows from current work and continues a way of working in which I have connected product, development, delivery, and operations for a long time.
View the current proofWhere this creates value
We can start with a concrete product problem, a constraint in the delivery flow, or the next sensible step in autonomy. What matters is shaping user value, accountability, quality, and operations together.
