Outcomes
Kochi turns scattered prompt logic into a governed system for shared AI behavior. By defining reusable blocks, visible update states, conflict resolution, and reviewable Cowork changes, I gave the team a clearer foundation for building AI workflows that people can inspect, change, and trust.
Role
Founding and sole product designer. I worked directly with engineering to move the product from model definition to working interaction patterns across prompt blocks, Cowork, update states, and AI-first design system rules.
The Problem
Teams adopting AI often start with freeform prompts: instructions in docs, chat threads, workflow builders, internal tools, and model configurations.
That works while one person owns the workflow. It breaks down when the same behavior needs to be reused across a team.
For example, a team might rely on an approval rule:
“Do not publish, export, or send analysis outside the workspace without human approval.”
In a copied prompt system, that rule can splinter quickly. One prompt says not to export without approval. Another says not to send analysis externally. Another adds a stricter condition for issuer-specific recommendations. Another still uses an older version.
The drift is not caused by carelessness. It happens because shared behavior is easy to copy and hard to trace.
Hypothesis: If Kochi treated prompt logic as shared system behavior, rather than isolated text, teams could reuse AI instructions without losing visibility into ownership, dependencies, and change.
Design Decisions
Kochi’s design challenge was not just making prompts easier to edit. It was defining how shared AI behavior should be owned, reused, changed, and trusted across a team.
Treat prompt logic as infrastructure
Instead of treating prompts as isolated text, Kochi structures them as reusable blocks: role, security, brand voice, formatting, approval, and other behavioral rules. A rule like “do not publish or export analysis without human approval” becomes a shared system object, not a copied instruction.
Make dependencies visible
Shared blocks create dependencies. A change to one block can affect multiple prompts, workflows, and owners. Kochi surfaces where a block is active so teams can understand the impact of changing shared behavior.
Define the lifecycle of change
Block updates needed more than a diff. Kochi distinguishes between updates that have already applied, newer versions available for review, and conflicts where shared changes collide with local edits. Conflicts block publishing until the user chooses whether to keep the local version, take the shared version, or compare the two.
Preserve authorship in AI-assisted editing
Cowork can suggest, explain, or apply edits to prompt behavior, so AI changes follow the same governance model. The user can see what changed, why it changed, and what still needs action.
Core principle: the agent acts, the author owns.
Approach
I translated the coordination problem into a state model for shared AI behavior: where a block came from, where it was reused, whether the shared version had changed, whether local edits existed, and whether the prompt was safe to publish.
I also used Claude to help move design-system governance into the codebase. Through AI-assisted coding, I was able to model surface rules, state logic, and implementation constraints directly in the product rather than leaving behavior rules in a static design doc.
That helped turn principles like “agent changes should remain visible and reversible” into concrete interface behavior: update indicators, conflict blockers, disabled publish states, reviewable Cowork changes, and consistent commit patterns.
Claude accelerated the modeling and implementation work, but I owned the design judgment, refining the output into product behavior and engineering guidance.
Results and Impact
This work gave Kochi a clearer model for teams managing shared AI behavior.
Prompts became compositions of reusable blocks with visible ownership, dependencies, versions, and update states. Instead of asking users to trust that shared logic was current, Kochi showed what changed, where it changed, who changed it, and what still needed action.
The result was a system where teams could reuse AI behavior without relying on memory, manual communication, or hidden prompt copies. This became the basis for implementation across the prompt editor and Cowork surfaces.