12+
Specialized agents designed
4+
Products shipped through the pipeline
1
Conversational partner (voice + text parity)
0
Silent AI fallbacks tolerated
Case study · Jorge Martinez
Ship Something™
Founder & Product Designer
I am the product owner and designer. I set direction, wrote the design principles, shaped every agent's job and personality, and paired with AI coding agents to build the platform itself — talking through problems in conversation, reviewing output, and encoding what I learned into rules so the system could not regress.
- Timeline
- 2024 — Present
- Market
- Zero-to-one builders
- Discipline
- Product design · AI UX · Design systems
The command center I designed — where one builder runs a full product team.
Background
Why I started building this
Product designer with roots in advertising — UI, UX, and product work across automotive, recruitment, pharma, and campaigns for Nike, Volkswagen, and Pfizer. Multiple startup attempts taught me the same lesson: I could always get to a convincing prototype; finding developers to finish the job was the recurring wall.
When AI-assisted coding closed the build gap, I did not want another demo generator. I wanted the team I never had — specialists who care about demand validation, brand consistency, security, and launch readiness — without me becoming the integration layer between twelve disconnected tools.
Market & problem
Who it is for and what was broken
The market
Zero-to-one builders: design-driven non-coders, AI-leveraged developers, and product-focused founders.
They are not impressed by a polished landing page on a half-built product. They want to charge real money for what ships.
The gap I saw
Lovable, Bolt, Replit, and general-purpose assistants optimize for the demo moment. The gap I saw was the charge-a-dollar moment — production quality, brand coherence, and launch discipline.
The problem to solve
Solo builders use one AI for everything. Code, copy, security, and launch checks blur together; nothing gets full attention. The builder becomes project manager, integrator, and quality control — exhausted before the product is real.
Approach
How I chose to solve it
One partner, many specialists
Users talk to a single orchestrator. Behind it, each agent owns one objective — PRD Maker™ for requirements, Dev Moat™ for security, Pre-Launch Check™ for launch blockers.
Conversation first, UI follows
Voice and text share one transcript. I design which surfaces default to voice (onboarding, brainstorms) vs text (PRD review, checklists) — but switching never drops context.
Principles as infrastructure
Design principles are not slide-deck values. They live in agent rules, CI gates, and commit contracts — so "no silent fallback" and "human in the loop" are enforced, not hoped for.
My role
Product owner, designer, and agent partner
I did not hand off specs to a dev team. I stayed in three modes at once: Product Owner — what ships and in what order; Product Designer — flows, principles, brand canon, and every conversational surface; Builder — pairing with AI coding agents to implement, then encoding failures into rules so the platform learned.
With the in-product agents, I am the human in the loop: I set direction in conversation, approve or reject their proposals, and own every irreversible decision — credentials, launch, brand commits.
PRD Maker™
Brand Standard™
Virtual User™
Pre-Launch Check™
Dev Moat™
Buzz Writer™
Six of twelve plus — each agent one objective, one handoff, one audit trail.
A typical day
How I actually worked
- Morning
Set direction with the orchestrator
Voice or text: "What's blocked on DollarPDF?" The orchestrator surfaces tasks Brand Standard and Virtual User queued overnight. I approve copy variants, reject one that drifted off-brand.
- Midday
Design a new flow, build through conversation
I describe the pre-signup ceremony in plain language — naming ritual, mic permission, partner activation. Cursor agents implement; I review in the running preview, not just the diff.
- Afternoon
When AI says "done," I verify
A build passes lint but the landing page still shows template copy. I trace the failure, update the rule ("never ship template defaults"), and add a gate so it cannot recur. Problems become permanent guardrails.
- Evening
Ship proof, not slides
Run a contrasting PRD through the pipeline — commerce vs outdoor vs utility — and confirm outputs actually differ. The case study only counts if the products are real.
When things broke
Problems became guardrails
My process when something failed: reproduce it as a user story, find the class of failure (not just the instance), fix it, then add a gate so it cannot return.
AI claimed "done" but data never saved
Designed persistence proof: every write must read back. Added schema-coherence checks so column mismatches fail at build time, not in silence.
Every generated product looked the same
Traced archetype, media strategy, and page-planner defaults converging. Redesigned differentiation as a first-class design problem — verified with contrasting PRDs, not one happy path.
Brand drift on pricing and checkout
Wrote brand canon as enforceable rules — sharp corners, zinc palette, grid-px borders — with automated CI that rejects off-brand utilities.
The arc
How we got here
- 01
Template → platform
Started selling a production Next.js template. Realized the business was the intelligence layer, not the repo — and that giving away the build apparatus leaked the moat. Pivoted to one hosted platform.
- 02
Generalist → specialized agents
Split one assistant into twelve single-objective agents. Designed how they hand off context and how the user still feels one relationship.
- 03
Screens → conversation
Made conversation the primary interface. UI updates live; forms are optional. Engine guarantees voice parity so text is never a second-class path.
- 04
Demos → shippable products
DollarPDF, Fixm, IncaTrail, ElevatorPitch — each built through the same pipeline, distinct brand and archetype. Proof replaced pitch decks.
Design decisions
What I optimized for
Human owns irreversible calls
Credentials, launch go/no-go, and brand commits stay with the builder. Agents execute; the UI shows who decided.
Honest failure over fake output
When generation fails, inform, retry, backlog — never substitute template content and pretend it worked.
Teach real terminology
P0, deploy, environment variables — with plain-language context on hover. Users leave more capable, not more sheltered.
The naming ceremony
First session is a relationship ritual, not a form. Sets the tone for months of collaboration with the orchestrator.
Evidence
Screens from the work
Every frame is from the live platform or a product the pipeline generated — not a concept deck.
Takeaway
What this demonstrates
Ship Something™ is how I think about human–AI product design: one clear relationship for the user, strict specialization under the hood, and honesty when the model misses. I designed the system I wished I had as a designer who kept stalling at production — and I built it by staying in the loop with the agents every day.
- AI product interaction design
- Multi-agent orchestration UX
- Design systems & brand canon
- Failure-mode design for generative AI
- Founder workflow (design → ship)