Kochi
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
Through customer conversations, consulting work, and product partnerships with companies adopting AI, our team saw a recurring pattern: the people configuring AI workflows were often product managers, operators, and other roles that had not traditionally worked directly with code.
AI made it possible for these users to define software behavior through prompts, agents, workflow rules, and model configurations. But the systems supporting that work had not caught up. Teams were managing increasingly important behavior through instructions scattered across documents, chat threads, workflow builders, and internal tools.
This worked while one person owned the workflow. It became difficult to manage when the same behavior needed 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 could splinter quickly. One prompt prohibited exports without approval, another applied the rule only to external messages, and another still used an older version.
The drift was not caused by carelessness. It happened because shared behavior was easy to copy and hard to trace.
I helped translate these recurring customer needs into a product 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.
Defining the Product Model
Kochi’s design challenge was not simply 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 such as “do not publish or export analysis without human approval” becomes a shared system object rather than an instruction copied between prompts.
Expose dependencies before changes propagate
Reusable blocks create dependencies. A change to one block can affect multiple prompts, workflows, and owners.
Kochi shows where each block is active so users can understand the impact of a change before it propagates across the system.
Make version states actionable
Block updates needed more than a visual diff. Kochi distinguishes between changes that have already been applied, newer versions available for review, and conflicts where a shared update collides with local edits.
Conflicts block publishing until the user chooses whether to keep the local version, accept the shared version, or compare the two. The interface makes version and conflict states understandable without exposing the underlying branching and dependency model.
Keep AI-generated changes attributable and reversible
Cowork can suggest, explain, or apply edits to prompt behavior, but AI-generated changes follow the same governance model as human changes.
Users can see what changed, why it changed, and what still requires their attention. AI can accelerate the work without obscuring who is accountable for the result.
Core principle: The agent acts. The author owns.
Representative screens built with Claude Code to quickly model block state behavior, test interface logic, and give the team a shared reference for review and implementation. Best viewed on desktop.
Approach
I translated the coordination problem into a state model that tracked where a block originated, where it was reused, whether the shared version had changed, whether local edits existed, and whether the prompt was safe to publish.
I then designed how those technical states would appear to users through update indicators, comparisons, conflict resolution, publishing controls, and reviewable Cowork changes.
I used Claude Code to prototype the state model directly with Kochi’s production components and tokens. This allowed me to test interaction logic and implementation constraints in the product environment rather than leaving behavior rules in a static design document.
The prototype turned principles such as “agent changes should remain visible and reversible” into concrete interface behavior: conflict blockers, disabled publishing states, reviewable changes, and consistent commit patterns.
Representative screens — coded with Claude Code, reusing Kochi's production design tokens and components. Best viewed on desktop.
Results and impact
This work established a shared product model for how Kochi would manage reusable AI behavior across the prompt editor and Cowork.
It gave design and engineering a common definition of ownership, dependencies, versions, conflicts, and publishing safety, replacing a looser feature-by-feature approach.
The model became the basis for implementation across both surfaces. Users could see where shared behavior was active, what had changed, who changed it, and what required review before publishing.
The result was a system that allowed teams to reuse AI behavior without relying on memory, manual communication, or hidden prompt copies.
