Portfolio, Ventures & What I Build
Product/systems design that turns AI tech into business results
Contact Us
Contact form or information will go here.
Project Detail
Craftal
Summary
An AI-native workspace for generating, inspecting, and validating complex product workflows.
Complex products are often planned across documents, diagrams, tickets, and conversations, leaving teams without one dependable model of how the system should work.
I designed Craftal to turn product context into a structured, interactive system that teams can explore, inspect, simulate, and refine before implementation.
The Problem
Product teams were building from fragments instead of a shared system.
Product requirements rarely live in one place. Business goals might sit in a strategy document, user flows in Figma, implementation details in tickets, and critical dependencies in the heads of individual team members.
That fragmentation becomes especially dangerous in products with multiple actors, automated decisions, integrations, and operational rules. A workflow can look complete at the screen level while still hiding missing inputs, unclear ownership, broken transitions, or unsupported edge cases.
Product managers and designers can usually understand the intended experience, but they may not be able to inspect a technical specification. Engineers can read the implementation details, but those details often appear only after important product assumptions have already hardened.
The result is a familiar pattern: teams align around screens, then discover during implementation that they never fully aligned around system behavior.
I saw an opportunity to treat product definition as structured system architecture rather than a collection of deliverables.
The challenge was not simply to create another workflow canvas. Craftal needed to preserve enough operational detail for engineers while remaining legible to product managers, designers, and stakeholders. It also needed to make AI-generated work inspectable rather than asking teams to accept an opaque result.
Solution
A product model that moves from intent to structure to validation.
I designed Craftal around a simple hierarchy:
Activity → Task → Operation
Activities describe the major phases of a product workflow. Tasks represent discrete steps within those phases. Operations capture the concrete actions, actors, requirements, and dependencies needed to perform each task.
This gave the product a stable language for connecting business intent, user experience, automation logic, and implementation detail.
Users begin with high-level product context such as the industry, business domain, audience, use case, and product description. Craftal turns that context into a structured specification rather than generating a loose collection of screens or suggestions.
The important decision was to make the specification the source of truth.
The visual map is not a manually assembled diagram. It is a representation of the underlying product model. This distinction allows the same system to support different levels of abstraction without creating separate, contradictory artifacts.
Making complexity navigable.
The System Map became the primary workspace.
Activities appear as large structural containers, while tasks become connected nodes inside them. Actor colors distinguish work performed by users, humans, systems, and agents. Selecting a task opens an inspector containing its operations, execution history, inputs, outputs, and AI suggestions.
A synchronized tree provides a second navigation model for people who think hierarchically rather than spatially. Selecting an item in the tree focuses the corresponding graph node, connecting the product outline directly to the system visualization.
I deliberately avoided flattening everything into a single canvas. Activities, tasks, and operations require different levels of attention.
The graph communicates relationships and sequence. The tree communicates hierarchy. The inspector reveals operational depth only when needed. This progressive disclosure keeps the system approachable without concealing the detail required to evaluate it.
The interface also preserves the distinction between how a workflow is organized and how it behaves. A task can belong to an activity while also receiving inputs from other tasks, producing signals, triggering automated operations, and depending on external context.
Making AI work observable.
Craftal uses specialized agents for workflow generation, research, experience architecture, validation, and code-related tasks.
I did not want those agents to disappear behind a generic loading state. Mission Control exposes each agent’s current assignment, reasoning progress, completion state, and outputs.
This creates a clearer relationship between automated work and the product model it affects. Teams can see which agent produced an output, which task it relates to, and whether the work is active, completed, or waiting on another part of the system.
The goal was not to present hidden model reasoning as absolute truth. It was to provide useful operational visibility: what the agent is doing, what stage it has reached, and what artifact it contributed.
Validating behavior before implementation.
A system map can still create false confidence if teams only inspect its static structure.
I added Product Simulation so users could step through the proposed workflow in sequence. Completed tasks, active work, pending steps, and activity groupings remain visible as the simulation progresses.
This creates a practical review mode for product teams. Instead of discussing whether a diagram “looks right,” they can walk through how the product is expected to behave.
A product manager can catch an incorrect sequence. A designer can identify a missing user interaction. An engineer can question an unsupported transition. A stakeholder can understand the complete workflow without reading JSON or implementation tickets.
Together, the System Map, agent visibility, context relationships, and simulation form a connected product environment rather than a set of unrelated AI features. Craftal’s product manual describes this as a unified workspace for graph-based system mapping, agent monitoring, knowledge dependencies, and step-through validation.
Outcome
From disconnected artifacts to an inspectable product architecture.
Craftal established a working model for turning ambiguous product context into a structured system that different disciplines can examine from their own perspective.
The prototype demonstrates how teams could:
- Move from product intent to a consistent workflow specification
- Explore the same system through hierarchical, spatial, and sequential views
- Trace tasks back to operations, actors, inputs, outputs, and context
- Observe the agents contributing to generated product work
- Surface missing dependencies and workflow risks earlier
- Validate behavior before development begins
The most meaningful outcome is the product thesis itself: requirements, workflow diagrams, AI agents, context, and simulation do not need to exist as separate tools.
They can operate as different views of one structured product system.
Craftal is still an evolving product, so I am not presenting deployment or revenue metrics that do not yet exist. Its current value is demonstrated through the functional prototype, the coherence of the system model, and the ability to move from abstract requirements to something visible, explorable, and testable.
The project also brings together several themes that have shaped my work across enterprise platforms and AI products: workflow architecture, progressive disclosure, human oversight, technical visualization, and the translation of complex operational logic into interfaces people can actually reason about.