A friend of mine recently took on their first internship as a design engineer. I just started my first role as a senior design engineer. I wanted to capture my workflows — and what I think is a good path forward for anyone doing AI-assisted engineering.

If you’re reading this, you’re already ahead of the curve. And everything about AI engineering is a loop.

The Loop is Everything

What makes design engineering special is the tight loop: build, show someone, collect feedback, iterate.

Be a little extra customer-obsessed. Some companies get an unfair advantage from people who don’t just ship — they stay close to customers and accountable to outcomes on a short timeline. It’s not the only way to work, but for the right kind of work it’s powerful.

So you’re looking for opportunities to:

• Build stuff
• Get in front of users
• Be accountable to their experience
• Iterate

Start Close to Home

Start small, and start at home. Tools for yourself — date-night planners, meal planners, personal utilities — are genuinely fun to make. Show them to friends and family, watch them try, and you’ll start to build taste for when the loop works and when it doesn’t.

There’s nothing wrong with being ambitious — wanting to build a business, monetize, all of it. But be intentional about what you’re trying to learn. Becoming a design engineer, learning to ship, and starting a business are three different skills.

Start Small (Smaller Than You Think)

Building an app is fun, and it forces you to learn a lot of ideas and techniques. But you can start smaller — build a tool.

Remember: we want to get really good at the loop. A tool can just be an index.html file. Even the apps I build usually start that way — a single page that demonstrates the concept, that I can play with and quickly share to see how someone uses it.

The first thing I ever made was a bookmarklet — just a snippet of JavaScript. You’re shrinking the loop down to almost nothing. Still learning, still iterating fast.

When You’re Ready to Build an App

Building an app is trickier than building a tool — now you’re thinking about deployment, hosting, databases. It can be overwhelming.

The best way to approach it: look for starter code.

Find a repository on GitHub that already works. Bring it into Cursor or Claude Code and say: “Help me get this running on my computer.” Play around, ask questions, build a mental model of how it works. Then you can start modifying it.

If you ask Cursor (or anything similar) to generate something from scratch, there’s often not enough context and the results suffer. AI tools are much better at modifying working code than writing it from nothing.

A good starting point: Next.js examples. You can probably find one close to what you want.

Find a Mentor

Easier said than done — but try to find a friendly person who’s a few rungs ahead of you, someone with programming experience you can actually talk to.

Express your interest, explain what you’ve been doing, and ask them directly if they’d be willing to help.

Real engineers know the highest thing they can do is make the next engineer a bit faster, a bit safer, and a bit more informed. You’ll know you’ve found the right one if they say yes.

Planning for Bigger Loops

Now the loop gets bigger. You’ve got an idea, you’re really fleshing it out — and bigger loops need better planning.

Planning is becoming standard in AI-assisted development. Use the plan tool in Cursor or Claude Code to get a clear list of what needs doing. Ask questions about the plan until you have a solid mental model of how it’ll work.

A good plan is:

• Small, incremental steps that are easy for a large language model to follow
• Clear about how to verify each step as you go

This is a key skill: breaking down user needs into requirements that are easy to verify in code. How well you do this depends on your experience writing tickets and working with developers — but it’s a practice. You just need to start.

Use Version Control

Use version control. It lets you work on branches and try things in draft.

My workflow: I make a draft branch for a feature and let my agent commit to it freely. Agents handle most of the Git work for you — and you’ll pick it up quickly by watching.

Once the branch is in good shape, I ask Cursor or Claude Code to create a fresh branch that implements the same feature with no regressions and a clean commit history. The result is a tidy log of the feature, and a repo that stays maintainable.

Using Code at Work

One reason I push people toward building close to home: getting onboarded into a workplace codebase can be brutal.

Depending on the company, team culture, and age of the codebase, it can get complicated. At a mid-sized company your codebase might be 10 years old, with countless setup steps. That’s frustrating for engineers — and especially frustrating for design engineers who don’t have all the background to ramp up.

There’s an idea that design engineers can drop in and ship quick CSS or copy tweaks. Whether that’s actually possible depends on the maturity of the codebase, the test coverage, and who’s around to support you.

One way around this: build tools, write code in standalone index.html files, or spin up small apps in new repos to demonstrate ideas. Build momentum — and your relationship with the engineering team — and you’ll find a path to production.

This is an industry-wide shift, and lots of engineers are thinking about it. If it’s hard for you to understand a codebase and get set up, it’ll be hard for a coding agent too. Expect downward pressure across the industry to make this easier. You can feel the shift coming.

Use High Quality Models

You really need to use high-quality models. Opus 4.5 is what I recommend to everyone getting started.

Yes, it’s pricier than Sonnet 4.5. But you’re worth it — and it’ll often save you tokens by doing smarter things and filling in your knowledge gaps.

Opus 4.5 is agentic, engages well with tools, and builds (and creates) context effectively. I’m consistently impressed by the quality of both its code and its analysis.

Previous models impressed me when they hit the 3 Cs: Context (window size, and the ability to understand and keep track of things within its window), Consent (identifying risks and problems, giving the user accurate descriptions, and seeking consent when it’s required), and Capability (reasoning effectively, multimodal understanding, and acting agentically by using tool calls to build its own context).

Opus 4.5 floored me because it nails all 3 Cs — and adds a fourth: Consistency. It does all of it, all day, until you’re the one who’s tired and needs to go to bed. You can’t go back to previous generations after this; you just see sparks of what 4.5 is.

Compare Yourself to Your Past Self

In the age of AI, it’s easy to get caught in hype cycles and feel like you’re being left behind. People keep saying things like “it’s so over” and “you’re not gonna make it.”

But here’s the thing: if you’ve made it this far in the article, you’re on the leading edge. You’re ahead of the curve. Don’t worry about it. Just take it slow.

Focus on the loop. That’s the through line. People who understand users, understand divergent and convergent thinking, and can navigate the loop — that’s what stays meaningful long-term.

A Quick Note on iOS and Android Apps

Hold off doing native app development when you’re just getting started.

I know it’s tempting to dive into iOS and Android. Hang out a little longer — the tooling isn’t quite there yet. Building up your web skills is great because the agent loop runs much smoother on the web.

If you’re ready for the challenge, build an iOS app. But if you’re after hardware, consider other directions — almost anything else is easier to build on than mobile.

The Path Forward

This isn’t about becoming the best engineer in the world overnight. It’s about finding your rhythm, building things that matter to people close to you, and getting really good at the loop: build, ship, collect feedback, iterate.

Start with an index.html file. Build a bookmarklet. Clone a Next.js example and modify it. Find a mentor a few rungs ahead. Use version control. Use the best models. And most importantly, stay focused on getting things in front of users and iterating.

You’re not behind. You’re right on time. Welcome to the trail.