Importance of Clarity

AI Product Management AI Product Management is evolving rapidly. The growth of generative AI and AI-based developer tools has created numerous opportunities to build AI applications. This is making it possible to build new kinds of things, which in turn is driving shifts in best practices in product management — the discipline of defining what to build to serve users — because what is possible to build has shifted. In this post, I’ll share some best practices I have noticed. Use concrete examples to specify AI products. Starting with a concrete idea helps teams gain speed. If a product manager (PM) proposes to build “a chatbot to answer banking inquiries that relate to user accounts,” this is a vague specification that leaves much to the imagination. For instance, should the chatbot answer questions only about account balances or also about interest rates, processes for initiating a wire transfer, and so on? But if the PM writes out a number (say, between 10 and 50) of concrete examples of conversations they’d like a chatbot to execute, the scope of their proposal becomes much clearer. Just as a machine learning algorithm needs training examples to learn from, an AI product development team needs concrete examples of what we want an AI system to do. In other words, the data is your PRD (product requirements document)! In a similar vein, if someone requests “a vision system to detect pedestrians outside our store,” it’s hard for a developer to understand the boundary conditions. Is the system expected to work at night? What is the range of permissible camera angles? Is it expected to detect pedestrians who appear in the image even though they’re 100m away? But if the PM collects a handful of pictures and annotates them with the desired output, the meaning of “detect pedestrians” becomes concrete. An engineer can assess if the specification is technically feasible and if so, build toward it. Initially, the data might be obtained via a one-off, scrappy process, such as the PM walking around taking pictures and annotating them. Eventually, the data mix will shift to real-word data collected by a system running in production. Using examples (such as inputs and desired outputs) to specify a product has been helpful for many years, but the explosion of possible AI applications is creating a need for more product managers to learn this practice. Assess technical feasibility of LLM-based applications by prompting. When a PM scopes out a potential AI application, whether the application can actually be built — that is, its technical feasibility — is a key criterion in deciding what to do next. For many ideas for LLM-based applications, it’s increasingly possible for a PM, who might not be a software engineer, to try prompting — or write just small amounts of code — to get an initial sense of feasibility. [Reached length limit. Full text: https://lnkd.in/gYY-hvHh ]

The ability to create clarity when there’s no shortage of chaos, opinions, and competing priorities is a rare skill. In any reasonably competent company, this skill alone will help take you quite far, fairly quickly. Concretely, this means creating clarity on the main problems, clarity on the right solutions, and clarity on the action plan & priorities. Very few people can do this well even though most people possess the intelligence necessary to do it. This is because most people in the workplace have been conditioned to add more information, sound more clever, satisfy more stakeholders, and feign more precision & certainty than is possible. Few understand that clarity in a chaotic situation can only emerge from subtraction, never from addition. Clarity comes from communicating what stands out as most important, why it is most important, how it will be achieved, and last but not the least, giving people a way of thinking about why it is okay, even great, that we aren’t doing All The Other Things.

I've been using Clean Architecture for 6+ years. Here’s why I think it’s amazing. 👇 The biggest pain in enterprise systems? A lack of structure. Every project reinvents the wheel. Every team builds layers differently. And knowledge doesn’t transfer between systems. But there’s a proven way to fix this. It’s called Clean Architecture. It’s not about how many projects you create. It’s not about fancy patterns. ✅ It’s about the direction of dependencies. Inner layers (domain, app) define abstractions. Outer layers (infra, presentation) implement those abstractions. Never the other way around. That’s it. That’s the rule. You can package this as: - Layers (domain, app, infra, web) - Vertical slices (grouped per feature) - Components (layers + vertical slices) They all work — if you follow the rule. What are the benefits? - Modular code - Clear separation of concerns - Easy-to-test business logic - Faster onboarding - Loosely coupled components Clean Architecture has helped me ship excellent products. And I’ll keep using it because it works. Want to simplify your development process? Grab my free Clean Architecture template here: https://lnkd.in/eDgfyWKB

Ambiguity fuels drama. Leaders often assume drama comes from difficult personalities or interpersonal conflict. But what I see consistently in my work is that drama usually grows out of ambiguity, not tension. It tends to show up when teams have: - unclear roles - unspoken expectations - vague priorities - inconsistent accountability And when people don’t know what “good” looks like, they start filling in the blanks with: - assumptions - rumors - alliances - emotional narratives In the absence of clarity, people create stories, because they’re trying to make sense of what’s happening around them. That’s why I often use this Clarity × Accountability 2×2 in my work with teams. It makes the invisible obvious. When both are low, teams fall into the Drama Zone. When one is high and the other isn’t, people end up in Fear or Resentment. But when clarity and accountability rise together, conversations get cleaner, decisions stick, and the emotional noise quiets down. Most people aren’t trying to be difficult. They’re just trying to find their footing in the fog. When clarity is present, the drama usually takes care of itself. #drama #clarity #leadership #learning #conflict #accountability #teams

"The Prompt Engineering Playbook for Programmers" My latest free write-up: https://lnkd.in/g9Kxa7hG ✍️ The difference between a vague "fix my code" request and a well-crafted prompt can mean the difference between generic, unhelpful advice and precise, actionable solutions that accelerate your development workflow. My "Prompt Engineering Playbook" has actionable strategies to help you get the most out of AI coding assistants. If you missed it, or need a refresher on crafting prompts that deliver real results, now's a great time to dive in. Inside, you'll find: ✅ Effective patterns (role-playing, rich context, iterative refinement) ✅ Smart debugging strategies with AI ✅ AI-assisted refactoring for better code ✅ Building new features step-by-step with your AI pair programmer ✅ Common anti-patterns to avoid (and how to fix them) Here's what separates developers who struggle with AI from those who use it effectively: 🎯 The Foundation Rich context: Never just say "fix my code" - specify language, framework, error messages, and expected behavior Clear goals: Replace "this doesn't work" with "this function should return a sorted array but returns undefined" Break it down: Don't ask for entire features - iterate from skeleton → logic → optimization ⚡ Refactoring game-changer ❌ Vague: "Refactor getCombinedData function" ✅ Specific: "Refactor to eliminate duplicate fetch logic, parallelize requests, and optimize data merging. Preserve individual error messages." Result: AI delivers parallel fetching, efficient data structures, and maintains debugging capability. 🎭 Secret weapon: role playing "Act as a senior React developer reviewing this code for performance issues..." "You're a TypeScript expert - refactor following modern best practices..." This simple technique dramatically improves response quality and specificity. ⚠️ Avoid these anti-patterns - Overloaded prompts ("build a complete app") - Vague success criteria ("optimize code" vs "reduce memory usage") - Ignoring AI clarifying questions - Inconsistent style across conversations 💡 Bottom line With AI, the more context and direction you provide, the better your results. I hope it's a helpful read. #ai #programming #softwareengineering

As Duarte grew, I’d hear feedback that decisions were made too slowly, which confused me. In reality, we didn’t have a system to recognize when the team was asking for a decision. We thought they were just informing us, so decisions would languish. We weren’t ignoring them, failing to act, or even making incorrect decisions... We just didn’t realize a decision needed to be made in the first place. It dawned on the exec team that the lack of clarity during the conversation is what slows teams down. Leaders and teams can share the same language for decision-making. Much of it is about shaping recommendations that actually lead to the right type of action and making the urgency clear. Here’s the shift that changed everything… We started mapping every decision against two factors: urgency and risk. Low risk, low urgency: Decide without me. Your team runs with it. Low risk, high urgency: Inform on progress. They update you, but keep driving. High risk, low urgency: Propose for approval. They bring a recommendation, and you decide together. High risk, high urgency: Escalate immediately. You're in it together, right now. Once my team understood which quadrant a decision lived in, they knew exactly how to approach me. And I knew exactly what my role was. The framework gave us a shared language. People can’t act on ideas if they don’t understand how decisions are made. Leaders should define how recommendations move from idea to approval to action. That transparency keeps progress from stalling. Remember: One of the biggest threats to your company isn't a lack of good ideas. It's a lack of clarity. #Leadership #ExecutiveLeadership #OrganizationalCulture #DecisionMaking

I said yes to everything. It nearly broke me. (this framework saved me): It's called The New Opportunity Test. Conference speaking gigs. Advisory roles. Side projects. Each opportunity felt like progress, but I was drowning in commitments that weren't moving the needle. A lot of good opportunities are actually distractions in disguise. Your success in life is proportional to your ability to say no. Before committing to anything now, I ask three questions: Question 1: Does it align with my priorities? You can have 2-3 key priorities max. Not 10. Not 5. Two or three. If the opportunity doesn't directly support one of these, it's a no. Most people fail right here. They chase cool instead of aligned. Question 2: Is it a hell yes? This comes from Derek Sivers. If you're not leaning forward in your seat, if it doesn't excite you at a visceral level—it's a no. Founders burn out from death by a thousand lukewarm yeses. Question 3: Would I still do it if it took twice as long and was half as rewarding? This reality check tempers your natural optimism about shiny new objects. Assume worse outcomes. If it still excites you, go for it. Three greens means go. Otherwise, it's a no. The greatest risk to your progress isn't lack of opportunity. It's lack of focus. Every yes is a no to something else. Use this test to filter noise, protect your focus, and build with precision. Your future self will thank you.

🪂 How To Make Your Design System AI-Ready (https://lnkd.in/dtnpy7CM), a practical guide on how to reduce drifts, minimize mistakes, maintain context and improve the quality of AI-generated prototypes — with structured spec files, automated auditing and token layers. Put together by Hardik Pandya from Atlassian. --- 🔹 1. Design Decisions Are Infrastructure AI-generated prototypes often don't deliver consistently decent results because of tiny inconsistencies scattered all across a design system. Often it's decisions made but not documented, hard-coded values never cleaned up, or relying too much on AI making sense of mock-ups or design flows on its own. Unsurprisingly, better AI prototypes come from better data — but also from better human guidance. We shouldn’t assume that AI knows how to choose the right component, and how to design with accessibility in mind. It needs priorities, a clear path on how we make decisions, design principles, examples, do's and don'ts. In fact, we should treat design decisions as infrastructure. That means that every time we make a decision — not just a design decision, but even decision on how actually prioritize our work and how we make decisions around here — it must find a path into the spec file that is then consumed by AI. --- 🔶 2. Three Layers: Spec Files + Token Layer + Audit To ensure quality, we establish design principles, guidelines, rules in a form of “spec files”). It's structured Markdown files that include spacing rules, color choices, component usage guidelines, priorities etc. AI is going to read and reuse that spec file every time it's going to generate a prototype. Because the spec files are text files, it's much more cost-effective, but also much more accurate just because we don't rely on AI recognizing or decoding patterns from mock-ups, but gets specific guidelines instead. In fact, extending code is often a more effective way than generating code from mock-ups. Token layer lists and keeps updated all tokens used throughout the design system. AI always chooses from a closed set of named variables instead of inventing plausible values ad-hoc. An audit script catches what AI gets wrong. It scans the prototype and flags every hard-coded value and flags it if necessary. It can be a regular software doing that, with AI waiting for its feedback to come back. Finally, when a design system ships updates, a sync routine flags which spec files need updating. The goal is to make sure that AI always reads up-to-date, current specs, not the ones written against an outdated version. --- 🔺 3. Examples of AI-Ready Design Systems ⌾ Atlassian: https://lnkd.in/dVsGc3Cp ⌾ Carbon: https://lnkd.in/d4zq4WWb ⌾ CMS Design System: https://lnkd.in/dHHzV3en ⌾ Nordhealth: https://lnkd.in/d8C4j2ZA Yet again, AI can’t magically resolve technical debt or design debt — it needs guidance, decisions, priorities and principles.

Most people call this "overkill." It’s not. This is a Japanese ground crew member performing a standard aircraft door check using Shisa Kanko (pointing-and-calling). Point. Look. Speak. Confirm. Every seal. Every lock. Every angle. In safety-critical environments, the goal isn’t to look efficient. It’s to make human error almost impossible. Japan didn’t build one of the safest aviation and rail systems in the world by relying on memory or motivation. They built physical systems that force attention. According to Japan’s Railway Technical Research Institute, this simple habit of pointing and calling out status reduces workplace errors by up to 85%. Yet most modern workplaces do the exact opposite: ↳ We celebrate raw speed. ↳ We reward looking busy. ↳ We quietly push people to skip the "routine" steps. Then we act surprised when a critical detail slips through. If a process only gets followed when someone is watching, you don’t have an operational standard. You have a performance. Excellence is rarely about complex strategy... it's usually just consistency that looks extreme from the outside. What’s one "too thorough" habit in your field that secretly prevents disasters? #Leadership #Operations #Execution #BusinessStrategy #SystemsDesign

90% of teams don’t fail because of lack of talent. They fail because nobody knows who owns what. I’ve seen strong teams with senior people and clear goals still miss deadlines, clash on decisions, and redo the same work twice. Not a skills problem. A clarity problem. Two things were always mixed together: execution and decision-making. So I separated them. RACI → for execution clarity Who does the work Who owns the outcome Who gives input Who stays informed DACI → for decision clarity Who drives the process Who makes the final call Who contributes Who gets informed What changed: • Meetings got shorter • Decisions got faster • Accountability became obvious • “I thought you owned this” disappeared The key insight: RACI fixes execution chaos. DACI fixes decision chaos. Most teams try to solve both with one framework and end up with neither. What I do now: – RACI at the start of every project – DACI for every meaningful decision – No shared ownership – No shared final approval Clarity scales. Ambiguity kills velocity. If your team feels busy but stuck this is probably what’s missing. – Natan Mohart