Technical designer, design engineer, and product builder.
I build developer tools, platforms, and infrastructure software by combining design, engineering, branding, and product strategy into one discipline.
My work focuses on building 0→1 companies and products where design isn't a layer applied afterward—it is fundamental to how the technology works.
Currently working on building and developing new tools, ideas and products. I'm exploring the intersection of agentic workflows and how they can redesign our interaction with our existing software systems (through CLI, MCP, UI and automations). Over the past 1.5 years, I've dove into a new stack of agentic tools and possibilities; expanding my capabilities and ambitions. Now I'm focusing on the broadened landscape of opportunity. It's an exciting time to be building, exploring and shipping things.
More than ever, there's an urgent need for a point of view in what we build. When anything is possible, the design perspective is crucial, to center what we do on user value, first-principles and the evolving needs of the user. The right framing can quickly map to powerful deliverables via the new AI capabilities we find ourselves wielding. Small, focused teams and builder communities have an especially powerful advantage now, and I'm energized by what is clearly being a reset moment for our industry, our ways of doing things and the ability to create, share and own more of the surfaces of what our work is.
I love the constraints and energy of early-stage work: shipping fast, gathering signal from users, and iterating based on real human-centered problem-solving patterns.
- AI Developer Tools
- Model Context Protocol (MCP)
- WebAssembly (Wasm)
- Kubernetes
- Platform Engineering
- Microservices
- CLI Design
- Design Systems
- Developer Experience (DevEx)
- Documentation UX
I help technical teams solve difficult product problems by combining:
- Design Engineering
- Product Strategy
- Front-end Engineering
- Brand Systems
- Open Source
- Developer Experience
- Technical Communication
Rather than separating design from engineering, I believe the best developer products emerge when implementation, interaction design, documentation, and product thinking evolve together.
- Reduce cognitive load.
- Documentation is part of the product.
- Design systems outlast individual screens.
- Build interfaces engineers can implement.
- Prioritize clarity over decoration.
- Great developer experience compounds over time.
- Fermyon
- Spin
- Helm
- Porter
- Brigade
- Krustlet
- Open Service Mesh
My work doesn't resemble the highly polished, animation-heavy style common in consumer startups. Instead, it prioritizes clarity for technical audiences.
Typical traits include:
- restrained color palettes
- strong typography
- generous whitespace
- layouts that emphasize hierarchy over decoration
- minimal visual noise
This fits the audience of developers, who tend to value readability and efficiency over visual spectacle.
A recurring theme in my talks and writing is consistency.
Rather than creating isolated mockups, I focus on:
- reusable UI components
- coherent iconography
- scalable documentation
- consistent spacing and typography
- systems that engineers can implement without ambiguity
That makes sense given my role as a "technical designer" embedded with engineering teams.
Fermyon's branding avoids many contemporary startup clichés.
Instead of:
- oversized gradients
- glassmorphism
- excessive illustration
- playful mascot-heavy marketing
the visual language relies on:
- bold typography
- simple geometric shapes
- careful use of accent colors
- clean layouts
- restrained motion
The result feels modern without chasing trends.
I treat documentation, blogs, and developer education as design surfaces.
For example, Fermyon's technical articles are structured to make code samples, diagrams, and prose easy to scan. Even posts about community metrics emphasize information architecture over decoration.
This is a hallmark of strong developer-experience (DevEx) design.
Unlike many product designers, I'm comfortable shipping production-quality front-end work.
That changes the design language in subtle ways:
- layouts are practical to implement
- interactions feel achievable rather than speculative
- components are designed with real browser constraints in mind
The distinction between "designer" and "front-end engineer" is intentionally blurred.
My work tends to avoid drawing attention to itself.
Instead of trying to impress with novelty, it focuses on:
- making interfaces understandable
- reducing friction
- giving information room to breathe
- helping users accomplish tasks quickly
It's a style that's closer to the philosophy of tools like Linear, Stripe's documentation, or GitHub than to highly expressive consumer apps.