Design Iteration Best Practices


 How to Iterate on a Level Blockout (Without Losing Your Mind) Iteration is the heart of great level design, but it can also be one of the most frustrating parts of the process if you don’t have a structure to guide you. When you're deep in a blockout, it’s easy to feel overwhelmed by feedback, second-guess your layout, or get stuck in a loop of endless changes.
 Here’s how I approach iteration to keep my head clear and the project moving forward:
 1. Set Clear Intentions Before You Build Before the first shape hits the grid, I define the goal of the space.
 Is it a combat arena? A narrative moment? A quiet place for exploration?
 This intention acts like a compass—every iteration decision is measured against it. If a change doesn’t support the core purpose of the area, it’s either reworked or cut.
 2. Feedback is Fuel, Not Fire It’s tempting to treat all feedback as immediate action items, but not all feedback is created equal.
 When I get notes, I do three things:
 • Group similar feedback
 • Separate opinion from objective issues
 • Ask “What’s the root problem?” Sometimes, what sounds like a request for a new layout is really about flow, pacing, or visibility. Identifying the why behind the feedback saves you from chasing your tail.
 3. Small Changes First, Big Changes Last I’ve learned to start iteration by tweaking flow and clarity within the existing structure before scrapping whole sections.
 You’d be surprised how far small shifts—like changing sightlines or moving cover—can go toward solving problems.
 Only when small changes can’t resolve the issue do I consider major reworks.
 4. Play, Test, Reflect—Then Tweak If you’re not playing your blockout regularly, you’re designing in the dark.
 After each iteration pass, I do a quick playthrough, often with a specific question in mind: “Does this feel too linear?” “Is the player seeing the objective when they need to?” “Can they identify a path forward without stopping to think?” Recording a play session or watching someone else play it blind can reveal blind spots instantly.
 5. Track Your Changes and Learn From Them I keep a running log of iteration changes and the reason for each. This not only helps me understand how a level evolved, but it also builds my library of design solutions I can refer back to on future projects.
 Final Thought:
 Iteration isn’t failure—it’s refinement. Every tweak is a step toward a better player experience. Build with intention, respond with clarity, and keep your goals visible. You’ll be amazed at how smooth the process becomes. If you’ve got your tips for surviving the iteration loop, I’d love to hear them. How do you keep your brain from melting during blockout changes?

Back in the day I worked on a major platform revamp. The objective was to remain competitive and meet regulations. At the same time our biggest competitor was also upgrading their system. Both were huge, multi-year projects with lots of investment. Our competitor started ahead of us. But, we had a key strategy: → Rapid adoption with shorter cycles! Instead of waiting for a big reveal after three years, we rolled out capability periodically. This let us constantly improve our platform based on real-time customer feedback. Our competitor went with a traditional approach, aiming for one major release at the end. The result? By the end of three years, we had not only improved our NPS score but also taken a larger part of the market share! Our strategy kept us agile and responsive, letting us adapt quickly to market changes and customer needs. Our competitor launched an outdated system that couldn't meet current demands. Here's what we learned: 1. Customer-Centric Development: ↳ Frequent releases allowed us to gather and implement customer feedback continuously, enhancing user satisfaction and engagement. 2. Iterative Improvement: ↳ Rapid iteration enabled us to pivot quickly and address any issues or new opportunities that arose during the development process. 3. Competitive Edge: ↳ By staying ahead of trends and being first to market with new features, we were able to capture more market share and strengthen our position. In tech, speed isn't just about being fast—it's about efficient adoption. 👉 Rapid adoption and continuous iteration transforms a good product into a great one, and adds a massive competitive advantage to the company. It can also ensure survival.

Design iteration can get messy. It's usually controlled during production because engineering teams follow structured, logic-based processes that are hard to change quickly. However, these controls need to be more flexible to unlock the full value of design. Alessandro Trezzi has a great question on my last design iteration post. “How do you see iteration working within agile sprints?” Paraphrasing, he observes that once a feature ships, it’s often seen as "done" unless market pressure demands changes. Iteration usually happens only during development, while later improvements end up in a backlog that’s often ignored as new priorities take over. 🚀 Here’s how we approach this scenario: Design doesn’t follow a single track because it involves overlapping cycles. To manage this, we use three different mindsets. UX metrics are common across all tracks, which help us align discussions, communicate clearly with stakeholders, and connect the work to its design impact. Concept Track ↳ Create and improve ideas by gathering user feedback to ensure they’re ready before building. Production Track ↳ Turn improved ideas into prototypes and fully developed designs for real-world use. Analytics Track ↳ Track how live designs perform to decide if they should stay, be updated, or be replaced. 🤔  What does this mean? 1. Flexibility over strict processes ↳ Different tracks (concept, production, analytics) have their own timelines, which can vary weekly. Keeping them aligned requires flexibility because not every problem can be solved in a week, a month, or even a year. Example: If a feature idea takes months to develop but analytics need to be tracked weekly, the team should focus on gradual improvements without forcing rushed solutions. 2. Use UX metrics to bridge mindsets ↳  UX metrics connect ideas across all three mindsets (concept, production, analytics). These metrics can reveal opportunities to link cause and effect in the work. Example: Track "time on task" to see how initial design concepts evolve into prototypes, eventually impacting usability when live. 3. Involve the whole team in feedback ↳  Include everyone in feedback sessions so the origins of ideas are clear and everyone knows which assumptions will be tested during production. Example: During a review meeting, designers, engineers, and advocates discuss which prototype features are based on user feedback and what will be measured in live testing. 4. Align analytics to original assumptions ↳  Analytics should stay focused on the initial assumptions. Broad or vague data doesn’t build confidence in the results. Example: Instead of reporting general user activity, measure specific metrics, like whether a new navigation menu reduced task completion times as intended. We can explore ideas as needed in the conceptual track, using research to evaluate new directions. For most companies, design teams usually focus on improving and building upon an existing product. What's your approach?

#14 I Habits To Keep Designers Honest. One of the most significant risks in design isn’t lack of skill; it’s self-deception. The mind is clever at hiding weak ideas behind confidence. That’s why the best designers build habits that keep their thinking honest and transparent. It’s not about perfection but creating a system that keeps you open, curious, and grounded. Here are a few things designers can practice: Externalise your thoughts quickly. An idea in your head can feel flawless, but the moment you sketch it out or put it on screen, its gaps become visible. The faster you make your thinking visible, the quicker you can fix what’s not working. Try naming your hunch. A simple one-line belief like “Users need X because Y”. You can check if that belief holds in the next session or user interaction. If it doesn’t, you’ve learned something important before wasting time. Perspective also matters. Looking at your idea from different angles can change everything. Step into the shoes of a user, then switch to a competitor, an investor, or a critic. Each lens shows a different weakness or strength, keeping you from getting stuck in a single way of thinking. Another powerful habit is inviting dissent early. Ask a teammate to review your work - not to praise it but to poke holes in it. A simple critique in the beginning can prevent big problems later. Finally, make time to reflect. At the end of every sprint or project, note down what guided you well and what misled you. Try to notice your patterns. Over time, this will build a mental habit of checking in with yourself. Designers who are honest with themselves build better products faster. This is not because they have fewer blind spots but because they’ve trained themselves to look for them.

🤦🏻 “How We Run Design Critiques at Figma” (https://lnkd.in/eERQmRnY), an honest case study by Noah Levin with helpful techniques and templates to run more effective design critiques ↓ 🚫 Most critiques are an avalanche of unstructured opinions. ✅ Good critiques are inspiring, and give you a plan of action. ✅ Critiques work best with 2–6 people in the room. ✅ Explain the problem before showing any work. ✅ Reiterate previous findings, decisions and research. ✅ Explain how far you are: 30%, 60% or 90% done. ✅ Explain what kind of feedback you are looking for. ✅ No Keynote/Powerpoint: Figma link + Observation mode. ✅ Assign a note-taker to capture key points (Google Doc). ✅ Show what you want to show: feedback is shaped by that. 🚀 Critique formats: 🎡 Round-the-room: everyone voices their feedback (2min / person). 🍿 Popcorn: freeform comments for flowing conversation. 🥁 Jams: for early explorations with brainstorms, group sketching. 🫱🏻🫲🏾 Pair design: for deep collaboration on a problem (small groups). 🤫 Silent critiques: for a large volume of written, structured feedback. 📋 Paper print-out: for complex flows and reviewing more at once. 📣 FYI critiques: for sharing context and invite feedback later. Design critiques are about applying critical thinking. It’s about how well a current iteration of design does what it’s trying to do. However, designers alone often don’t have the full picture. Don’t necessarily reserve critiques to design teams only: invite developers and stakeholders and PMs for early feedback. Don’t ask what people think — ask how well the design tackles a specific problem. And probably the most important thing is to enable a flowing conversations. Invite everyone to ask, to doubt, to scrutinize, but stay on point and gather structured feedback: that’s when good critiques emerge. Useful resources: Practical Design Critique Guide, by Darrin Henein https://lnkd.in/ey_cGKuc Mastering Design Critiques, by Jonny Czar https://lnkd.in/e_BYwNwf Anti-Behavior in Design Critiques, and How To Handle Them, by Ben Crothers https://lnkd.in/e4UrpsPs --- ⛵ Figma and Miro Templates Design Critique Meetings Guide (Figma), by Overflow https://lnkd.in/dE85MUAK Design Critique Template (Figma), by Janus Tiu https://lnkd.in/dCYp2MSY Design Critique Meeting (Figma), by Rodrigo Javier Peña https://lnkd.in/dP_8pCug Design Critique Playground Template (Miro), by Miroslava Jovicic https://lnkd.in/eryJShRd #ux #design

I'm not usually one to share my product design 'hacks.' Hope this helps more folks tap into the 🪄 of better product thinking. 1. Steal workflows from industries outside of tech. Architects, game designers, even chefs—everyone solves complex problems differently. Borrow their frameworks. It’s wild how much it improves your design logic and product flows. 2. Every new feature should subtract something old. If adding a feature doesn’t naturally replace or improve something else, you’re layering complexity. The best products stay sharp because they evolve—not accumulate. 💥 3. Use constraints to force better solutions. Limit the width. Limit the colors. Limit the interaction patterns. Constraints make you think deeper, and users will never feel the difference—except that everything just works. 4. Kill unnecessary settings. If a setting exists to “fix” something that could have been designed better by default, you’ve taken the lazy route. The best products have fewer decisions for users to make, not more. 5. Build interactive prototypes, even for simple ideas. Static designs don’t reveal problems—movement does. Sketch out transitions, hover states, and micro-interactions early. It sharpens your design instinct fast. 6. Start with mobile. Not because “mobile-first” is trendy—but because smaller screens force brutal prioritization. If the design works on mobile, scaling it up feels like a reward. 7. Test for boredom, not just usability. “Does this work?” is step one. Step two is asking, “Would I use this every day without hating it?” Usable products get abandoned. Engaging ones stick. 8. Design without data at your own risk. Placeholder content lies. Inject real (or semi-real) data early. Long names, weird edge cases, and incomplete info will blow up pixel-perfect layouts faster than anything else. 9. Never trust the first solution. The first design is often the most obvious. The second one starts to explore. The third version? That’s usually the winner. Keep pushing until it surprises you. --- PS - There are somehow 125,000 of y'all following along. Appreciate your support 🙏 🎁 For regular product design/product building insights, don’t miss ADPList’s Newsletter — my free weekly newsletter: https://lnkd.in/guJJsBaT

You should know when to move on from a design decision. The ideal answer is to test your decisions with a customer working group. But when that's not your reality, here is how I've moved quickly: 1. The Three-Question Check: - Does it solve the user's job to be done? Yes/No. - Does it align with our design principles? Yes/No. - Can it be built and iterated upon within our timeframe? Yes/No. If all answers are 'Yes', you've hit critical mass. 2. Gut Check with Data: Your intuition is valuable. But find quick ways to pair it with any known data and feedback (as limited as it might be): - Dig up surveys (e.g. post-purchase, churn, etc) - Ask sales & support (they get a lot of feedback) - Read product reviews Convergence with the average? You're there. 3. The Risk-Reward Ratio: Assess the risks of further tweaking. Minor aesthetic gains vs. potential delays? Time to move on. 4. Cross-Departmental Green Light: Quick alignment check-in with devs and PMs. If they're on board, it's a green signal. 5. The 80/20 Rule: Perfection is a myth. Aim for 80% solution that addresses the key needs effectively. You don't have to dig deep into every edge-case right now. Identify the ones with the most risk, and shelve the rest. John Wooden said it best: speed is your ally, but haste is your foe. Moving quickly is an advantage when you're methodical about how you do it.

It’s hard out here for a designer. 😓🧑🏾💻 You start with a clear concept. Then the revisions roll in. “Can we try it bigger?” “Now smaller.” “Can we go back to the first version… but with the second version’s vibe?” Nothing like the sweet taste of never-ending edits, right? Real talk though: endless revisions don’t just slow a project down. They drain momentum, strain relationships, and can push you straight toward burnout. And after a while, you’re not even refining the work… you’re just chasing opinions. Why it happens: 🚫 Unclear brief 🚫 Too many stakeholders, no decision-maker 🚫 Feedback that’s vague or late 🚫 Scope creep disguised as “one quick change” How to get it back on track: ✅ Get the feedback in writing (one thread, one source of truth) ✅ Lock a decision-maker + a review schedule ✅ Ask for specific feedback: “What’s the goal of this change?” ✅ Show 2–3 options tied to the objective (not just aesthetics) ✅ Track changes and flag when you’re outside scope ✅ Call the moment: “This is ready. Next step is final approval.” Design is iterative. But revisions should move the work forward, not keep it stuck. Have you been in revision jail lately? What’s your go-to move to get things back on track? #designlife #graphicdesign #creativeprocess #clientmanagement #designerproblems

Anyone can become a designer with AI. But how do you avoid designing slop? I got a masterclass from the man behind the newsletter Designing with AI, Xinran Ma. 🎬 Watch Now: https://lnkd.in/gjfmqJn6 Available Everywhere: Spotify: https://lnkd.in/eyt7agKj Apple: https://lnkd.in/eVZf64gB ✍️ Some of my favorite takeaways: 1. AI Design Is More Than Prompts Designing with AI covers five areas: prompting, ideation, design/prototyping, workflows, and staying conscious. Most people stop at prompts. That's just 20% of the skill. The rest is understanding systems, constraints, and behaviors. 2. Match Tools To Use Cases Custom GPT → effective prompts Lovable → high-quality prototypes Magic Patterns → design variations Google AI Studio → free exploration Cursor → full-stack experiences Claude Code → all-purpose 3. Good Design Passes Four Layers Visual representation, problem-solving, design principles, and implementation feasibility. Most people stop at layer one. They see something pretty and think they're done. Great design works at all four layers. 4. Context Matters More Than Prompt Length Include who the users are, what problem you're solving, what constraints matter, and where this fits in the product. More context equals better outputs. Don't just say "design a button." 5 Add Visual References To Prompts Text alone isn't enough. Upload 2-4 screenshots showing the aesthetic you want. These references anchor AI's output. The difference in quality is massive compared to text-only prompts. 6. Iterate Fast To Get Better Results The magic isn't in the first output. It's in the 10th iteration after you've refined and tweaked. Review, identify what's wrong, tell AI how to fix it, repeat. Speed comes from practice. 7. Always Validate With Real Users AI makes it easy to generate designs. Only users tell you if those designs actually help. Talk to users. Watch them use your prototypes. Listen to their frustrations. Don't skip this step. 8. The Workflow Changed From Linear To Parallel Before AI: sketch, wireframe, design, connect screens, prototype. Sequential. Slow. After AI: describe what you want, generate proof of concept, iterate freely. Parallel. Fast. This is how top designers work now. 🏆 Thanks to our sponsors: 1. NayaOne: The fastest way to test AI and fintech solutions - https://nayaone.com/ 2. Pendo: The #1 software experience management platform - http://www.pendo.io/aakash 3. Maven: Get 15% off Xinran’s course with my link - https://bit.ly/3Y2FUZn 4. Bolt: Ship AI-powered products 10x faster - https://lnkd.in/gyy3VB7Z 5. Gamma: Turn customer feedback into product decisions with AI - https://lnkd.in/g7YNKrJY Don't miss the episode for his live workflows.