What a design builder’s week looks like

By Imran Sheikh · 2026-11-12 · Design builders · 4 min read

Key points

  • The week mixes shaping, building, testing and reviewing in small loops.
  • Mornings go to problems, afternoons go to code and devices.
  • Reviews with engineers keep speed from turning into mess.

People ask what a design builder does all day. They picture a designer who became a developer and left design behind. The reality is closer to the opposite. The week has more design in it, because the loop from idea to evidence is short.

This is one pattern, based on how I work and how the studio works with clients. Your week will differ. The shape is what matters. Short loops, real builds and regular review.

Monday: pick the problem and write it down

The week starts with a written problem. One paragraph. Who is stuck, what are they trying to do, and what would a good outcome look like. If I cannot write it plainly, I am not ready to build.

Then I read the code around it. I want to know which components exist, how state flows and what the existing patterns are. An agent helps here. I ask it to explain a module, trace where a value comes from or list the screens that use a component. It is a fast way to learn a codebase I did not write.

  • Write the problem in one paragraph.
  • Find the existing components and patterns that apply.
  • Sketch two or three directions on paper or in a quick doodle.
  • Choose one to build first, and say why.

Tuesday and Wednesday: build in loops

These are the building days. I work in small loops of about thirty to ninety minutes. Describe the change to the agent. Read the diff. Run the app. Look at it on a device. Adjust. Repeat.

The loop is the craft. A single prompt rarely gives a good result. The second and third passes do. I ask for smaller moves: tighten the spacing, use the existing token, move the action closer to the thumb. Each pass teaches me something about the problem.

I keep a branch per idea. If a direction fails, I drop the branch and lose nothing. This is one of the quiet gifts of working in git. Throwing away work is cheap, so I throw away more of it.

Thursday: test it like a stranger

By Thursday there is something real. Now I try to break it. I use it one handed on a phone. I turn on larger text. I switch to dark mode. I run it on a slow connection. I put in a name that is far too long.

I also hand it to someone who has not seen it. Watching a person use a build for two minutes beats an hour of my own opinions. I stay quiet and take notes. The places where they hesitate are the places to fix.

  • Larger text sizes and small screens.
  • Empty, loading and error states.
  • Dark and light themes.
  • Slow or missing network.
  • One handed reach on a phone.

Friday: review, ship and write it down

Friday is for review. I open a pull request with a clear title and a short description of what changed and why. I attach a recording of the behavior. An engineer reads the diff and tells me what I missed. They usually find something. That is the system working.

Review is where trust gets built. Engineers see that a designer’s changes are small, tested and explained. Designers learn what the code needs. After a few rounds the comments shrink, and the pull requests move faster.

Then I write down what I learned. A few lines in the repo or a team note. Which pattern worked, which component needs cleanup, what to try next. This habit matters more than it sounds. Agents forget everything between sessions, so the notes become the memory.

Where the agent fits, and where it does not

The agent writes the first draft of the code. It explains unfamiliar files. It does the tedious refactor. It runs checks. I use it all day.

It does not decide what to build. It does not know the person who will use the screen. It does not feel the half second of lag that makes a screen seem broken. Those parts stay with me, and I guard them.

The agent drafts. I decide what stays.

What this does to the rest of the team

The biggest change is the conversation. Instead of debating a static file, the team looks at a running build. Product managers can click it. Engineers can read the code that produced it. Founders can hold it in their hands. Feedback gets specific because the thing is real.

Meetings shrink. A prototype answers questions that used to need a whole discussion. Decisions come sooner, and they are better, because people reacted to behavior and not to a picture.

Reviews also change tone. When everyone has used the build, the comments stop being about taste in the abstract. They point at a specific moment: this button is hard to reach, this transition is too slow, this message is unclear. Specific comments are easy to act on, and they leave less room for argument.

We build our own apps this way at the studio. The same weekly rhythm applies whether the project is a health companion, a block puzzle with cats or an arcade getaway game. Find the problem, build in loops, test like a stranger, review and ship.

You do not need to adopt the whole week at once. Pick a Tuesday and choose one small change in a real product. Build it with an agent, run it on a device and ask for review. One loop is enough to show you how the work feels.

Journal · Book a call · Home