How I Work Now

People have been asking what my day-to-day looks like now: friends, some teams I've been talking to. This is a start to that answer.

I'm a designer. My practice has shifted substantially in the last six months. For me, Claude Code is at the center of what I'm doing every single day. Here's what that looks like right now.

Claude Code every day. Canvas when necessary.

Every designer treats AI differently. Some use it as a fast path to comps, a way to generate directions before doing the real work somewhere else.

I love visual tools. I still do. But I spend most of my day in a terminal now. The canvas is where I go when the craft demands it.

I've had this moment more than once: I open a design file to start something, two or three minutes in, and it already feels too slow. The canvas wasn't the right starting point for that problem. Learning when it is has taken some time.

How deep I've gone

For better or worse, I go as deep as I can. Not because every approach is always optimal, but because understanding what a tool can actually do requires pushing its limits, especially if you want to make it your own: your own process, your own workflow.

Sometimes it's straight into Claude Code. Sometimes that's the paper sketching, taking a photo of that sketch and adding it to Claude Code on my phone and having it start building out wireframes and prototypes. All of these feed the same workflow.

We have always had to adapt to how the tools change. Sketch, Pixate, and Principle gave way to Figma. The path looks different now, but the pattern is the same.

I've had time and space to go deep on how these tools are evolving, and I've used it. I've maxed out Claude's Max plan for six weeks running. The question stopped being "how do I spend less?" a long time ago. How do I spend more efficiently and effectively?

What I'm using

Some built. Some borrowed. Explore and find tools and abilities and skills that others are making. If you can't find them, start making your own.

Built:

Ghostties is a multi-terminal fork of the Ghostty app where I can manage and work across multiple agents and repositories, with awareness of the status of each. There are a lot of tools coming up in this space. For me, I still wanted to stay focused in the terminal. When I'm building with Xcode and the simulator, I don't need everything else competing for attention.

The Orchestrator was the first thing that really transformed how I work. One long-lived thread that never writes code. It reads the full state of a project, decides what needs to happen, and delegates to subagents focused on specific disciplines. The core unlock is parallelism: separate threads running at the same time, on the same project, without opening new windows. The orchestrator also keeps a running state file per project so context doesn't get lost when windows clear. I'm putting together orchestrator-update and scaffolding skills too, for setting up and evolving the system over time.

Wrap and Wrap-continue are two skills in the same family that do different things. Some context first: every message in a Claude session includes everything that came before it. The longer a session runs, the more tokens move back and forth, and the faster you burn through your allotment. Managing that is part of the work now.

Wrap handles end-of-session close-out: committing the work, looping details back into the system, updating orchestrator files and my Obsidian knowledge base. Without it, I was spending the start of every new session re-establishing things I'd already established before.

Wrap-continue is for mid-task pauses. When the context window is getting large but the work isn't done, you don't want to close. Pause, write session notes, hand the thread off into a clean window and keep going.

DESIGN.md and design systems work is part of what I'm building too. Component patterns, design tokens, how a system gets established through agent context files. There's more to do here. It's a thread I want to pull much further.

Borrowed:

Compound Engineering handles brainstorming, planning, and code review across multiple dimensions at once. It covers a lot of the engineering rigor I don't fully have on my own.

Impeccable is for anti-vibe-code iterations: working on the fundamentals of good design, not just functional output.

Agentation adds a visual feedback layer to live interfaces, making design review faster without leaving the browser.

DialKit is real-time parameter tweaking. A floating panel for adjusting visual values live while the interface runs. No rebuild needed.

Remotion handles motion and video.

Canvas, connected

I use Paper.design, Pencil.dev, and Figma. All wired up via MCP, which means Claude can talk to them directly and make changes inside them.

Sometimes Claude is running iterations in Paper or Pencil while I'm doing something else. Multiple passes, different directions, without me actively guiding each one. Sometimes I go into the canvas myself, because some decisions need visual feedback: spatial tuning, typographic refinement. The places where I need to see it to judge it.

Both modes are deliberate. The goal isn't to stay in one place. It's to know which one the task needs.

Forward, not backward

Six months ago I would not have predicted this would be my day-to-day. Now I'm building and shipping native Swift and Mac apps, web apps, and websites. That still catches me off guard sometimes.

The learning is never done. Things I'm working through: Lottie and Rive for animation and motion, deeper agent specialization where each discipline carries its own context over time, go-to-market for Ghostties and Brukas, design systems at speed.

This is what one person can do. A group of people, all building this way together, is what I'm looking forward to.