• Build What Matters

    Using AI First Principles

    broken image
  • WHY WISER

    Build What Matters Using AI First Principles.

    Companies are trapped in bureaucracy disguised as process.

    They map workflows no one follows.

    They automate inefficiency.

    They measure what doesn’t matter.

    And when AI hits that mess?

    It doesn’t fix it.

    It amplifies it.

    The WISER Method was designed to change that.

    If AI First Principles are the mindset—WISER is the method.

    It gives builders a clear, step-by-step way to question assumptions, simplify complexity, and reimagine systems from the ground up—for a world where AI is part of the team, not duct-taped on at the end.

    WISER isn’t about tightening the bolts on broken processes.

    It’s about clearing space for better ideas, then building systems that actually deserve to exist.

    It’s lightweight. Practical. Built for people who fix things—

    and for people who imagine better ways to work.

    Its approach is simple:

    Question deeply. Act clearly. Reimagine what's possible. Build what matters.

    WISER PRINCIPLES

    • People Define Objectives
      Results matter. Compliance doesn’t. Every objective must have a human owner—because when AI misses the mark, it’s not the machine’s fault. It’s the person who defined the goal. Accountability is clarity.
    • Iteration Beats Specification
      Nobody starts knowing exactly what they need—and that's fine. Define what you want and what you don't want, then iterate fast. Planning documents lie. Prototypes tell the truth. People discover their real preferences through making, not thinking.
    • Question Everything
      Never accept a process without asking why it exists. Challenge everything, especially "that's how we've always done it. Sacred cows make the tastiest burgers.
    • Use First Principles
      Only physical limitations are truly unchangeable. Every other constraint—policies, traditions, "best practices"—can be questioned. Distinguish between actual constraints and artificial constraints to unleash real innovation.
    • Honor Human Creativity
      The best systems are designed for and by people who question, invent, and rethink from scratch. Keep humans in the loop where insight matters. Don’t replace what makes us great—amplify it..
    • Value Simplicity
      Fight complexity like your immune system fights infection. Simple and elegant methods and processes solve complex problems.
    • Success and Comfort Aren’t Compatible
      Progress lives in the uncomfortable space between tradition and innovation. Real transformation happens when established ways clash with new possibilities. Tension is the signal you're on the right track, not a reason to retreat.
    • Optimize for Speed
      Time is the one resource you can't get back. Reduce wait times, handoffs, and bottlenecks relentlessly. Slow processes cost more, frustrate, and kill innovation. People rarely notice perfect, but they always notice slow.
    • Measure What Matters
      Ignore vanity metrics. Track: objectives (did we hit targets?), demand (who actually needs this?), velocity (how quickly work completes), and exceptions (when following the process is the wrong choice).
    • Rebuild With Knowledge
      Use what you've learned to rearchitect the entire system, not just patch problems. Create something fundamentally better.
    • Automate Intelligently
      Use technology where it adds immediate value. Don't automate broken processes. Simple, obvious automation can happen anytime—not just at the end.

    WHEN PROCESS IS THE PROBLEM

    Agile: Freedom Turned Dogma

    Agile was supposed to be about flexibility. But somewhere along the way, it became a cage made of post-its. What started as four values and twelve principles morphed into ceremonies, roles, and rules that teams now follow like scripture. Entire days are spent managing the backlog. Sprints fill with meetings. Retrospectives rinse and repeat the same issues.

    And design? Agile shoves it into Sprint Zero—like a warm-up act. Treated as pre-work, not the work. It’s not built for imagination. It’s built to deliver fast—even when what you’re delivering is wrong.

    Agile still works for large software teams building complex, code-heavy products. But for the rest of us?
    It’s bureaucracy in a hoodie.

    Six Sigma: Process over Product

    Six Sigma obsesses over defects, variance, and statistical control. Great if you're building jet engines. But for most companies, it’s process theater—a ritual of mapping workflows no one follows to control problems that no longer exist.

    Design has no seat at the table. You don’t ask what should be built—just how perfectly it can be executed. Teams build elaborate models to fix irrelevant steps, while customers ghost quietly.

    It’s data worship without curiosity. Precision without purpose.
    All science. No sense.


    BPM: Process Prison

    Business Process Management is great when you need to show regulators a binder. But for anyone trying to solve real problems—it’s a straitjacket.

    BPM tools lock teams into rigid workflows. Change becomes risk. Improvement gets buried under documentation.

    Every time something breaks, instead of asking “should this exist?”—you get another process, another map, another gate.

    And design? Forget it. BPM doesn’t redesign anything.


    It documents dysfunction, wraps it in swimlanes, and calls it control.

    Process consultants call it structure. Your team calls it “why are we doing this again?”

  • WISER FRAMEWORK

    Three Phases: Review, Refine, Rebuild with Five Stages: Why, Identify, Simplify, Evolve, ReDngineer

    broken image
  • broken image

    Why

    Start by questioning everything. Define what the work is supposed to achieve, who it serves, and who owns the outcome—because if no one owns the "why," the rest doesn't matter.

    • Define Purpose
      Clearly articulate the process's core mission—its noble cause—in no more than two concise sentences (it must pass the "mom test"). Record why the process was created, who demanded it, and what value it is supposed to deliver. If you can't easily explain it, the process might not be necessary.
    • Question Everything
      Never accept a process without asking why it exists. Challenge assumptions, especially "that's how we've always done it." Most processes are 80% waste, 20% value. Sacred cows make the tastiest burgers.
    • Accept You Don't Know What You Want Yet
      Stop pretending you have perfect clarity from day one. Most teams lie to themselves about knowing exactly what they need. This is normal—nobody starts with complete understanding. The goal isn't to have all the answers upfront. It's to get honest about what you're trying to discover.
    • Define Objectives
      Specify exactly what the process must achieve using velocity planning: quickly list what you DO want and what you DON'T want. Be specific with measurable outcomes: "We want approvals in minutes, not days" and "We don't want people entering the same data twice." This approach is faster than detailed requirements and more honest about how discovery actually works. Replace vague targets like "improve efficiency" with concrete wants and don't-wants.
    • Assign Ownership
      Every objective must have a named human accountable. AI doesn’t decide what matters—people do. Whoever defines the objective owns the outcome. If no one owns it, stop there. You’re not ready to automate. This shifts how businesses work: Think less tech provider, more outcome insurer.
    broken image

    Identify

    Expose the gap between what’s documented and what’s actually happening. Map the real workflow, surface the dead weight, and name the sacred cows—because you can’t fix what you haven’t seen clearly.

    • Map Reality
      Capture how work is actually done—focus on real behavior rather than the "official" process. Identify the gap between documented procedures and day-to-day execution. Most flowcharts are idealized snapshots, not the messy reality. This mapping will start revealing what you actually want and don't want.
    • Catalog Waste
      Inventory every step that fails to drive the defined objectives. Look for redundant approvals, unread reports, endless meetings, and checks that catch nothing. This is about isolating non-value-add activities before any improvements are attempted.
    • Expose Sacred Cows
      Uncover processes that exist solely due to tradition or unchallenged assumptions. These "sacred" steps often persist because everyone assumes they're necessary. Challenging them will clarify what you actually value versus what you've inherited.
    • Keep or Cut
      Classify each step as "essential," "questionable," or "waste"—but pay attention to how this classification refines your understanding of what you want. The goal isn't just brutal honesty about current state. It's using that honesty to discover your real preferences for how work should flow.
    broken image

    Simplify

    Cut what doesn’t serve the mission. Ruthlessly remove anything unnecessary, ambiguous, or overcomplicated—because the best process is the one that no longer needs to exist.

    • Delete Ruthlessly
      Cut more than feels comfortable. If the value isn't obvious, eliminate it. Most organizations can remove 30-50% of their processes with zero negative impact. The discomfort of deleted processes reveals what actually needs to exist. You'll discover what you really want by removing what you definitely don't want.
    • Learn Through Elimination
      Each deletion teaches you something about your real priorities. Pay attention to what you miss when it's gone versus what you don't. This isn't just trimming waste—it's preference discovery through subtraction. What seems scary to remove often reveals false dependencies.
    • Prioritize Quick Wins
      Find waste you can eliminate immediately without rebuilding everything. Early victories build momentum and teach you about your real requirements. Don't wait for the perfect solution when good enough saves money today and clarifies what you actually need.
    • Try Low-Tech First
      Sometimes a checklist, clear ownership, or simple process fix works better than complex tech. Not every problem needs software. Many just need clarity. A $2 whiteboard often beats a $200,000 system—and teaches you more about what you really want.
    • Optimize Decision Ownership
      Sometimes the simplest fix is correctly assigning who makes a decision. Processes bog down because decision rights are placed too high in the organization or left ambiguous. Clarifying decision ownership eliminates more waste than changing the steps themselves.
    broken image

    Evolve

    Embrace monozukuri—the art of excellence through making. Let demand pull what's necessary while you iterate toward what you actually want. Each cycle should teach you something new about what really works.

    • Let Demand Pull What is Necessary
      When processes are deleted, actual needs become visible. Let this natural tension drive improvements, not schedules or targets. Work should happen because someone needs it, not because it's Tuesday. Real demand teaches you what you actually want.
    • Create Clear Triggers
      Develop explicit signals that start work only when real demand exists. Eliminate batch processing. Work should flow based on actual need, not arbitrary schedules. "Just in time" beats "just in case." These triggers will reveal your true requirements.
    • Build To Learn
      Create the simplest workflow that teaches you something new about what actually works. This is monozukuri—craftsmanship through discovery and making. Each iteration should answer: "Is this what we actually wanted?" Build to discover your real requirements, not to execute your first guess.
    • Iterate Based on What You Learn
      Use each cycle to refine your understanding of what you want and don't want. The perfect solution emerges through making, not planning. Resist rebuilding complexity—let simplicity teach you what really matters.
    • Measure What Moves
      Track end-to-end cycle time, handoff delays, and bypass frequency. If people are working around your process, that's data. Count how many "don't wants" you eliminate each cycle and how much clearer your "wants" become. Simple metrics: time from start to finish, number of exceptions, and clarity score of requirements.
    broken image

    ReDesign

    Now you know what you actually want. Redesign the system based on what you discovered, not what you originally planned. Build a system that learns and adapts as your understanding continues to evolve.

    • Apply System-Wide Thinking
      Often starting over is more effective than continual tinkering. Use insights from previous WISER stages to rearchitect the entire system, not just parts. You are not optimizing, you're reinventing based on what you've learned about what you actually want and don't want.
    • Blueprint based on Discovery
      Gather your WISER team to design the ideal process based on everything you now know about your real wants and don't-wants. Don't build to your original specifications—build to what you discovered through making and eliminating. This system should be lean, efficient, and aligned with your refined understanding.
    • Design for Continued Learning
      Build modular components that can adapt as your understanding evolves. Your system should support ongoing discovery, not lock in current assumptions. Design for the reality that your wants and don't-wants will keep getting clearer with use.
    • Automate Intelligence, Not Just Tasks
      When automation makes sense, embed logic that learns your preferences over time. Smart automation should get better at understanding what you want and don't want. Automate decisions based on your discovered patterns, not rigid rules. Keep humans in the loop for judgment and continued learning.
    • Measure Objectives and Velocity
      Build scorecards that track both results (are we hitting objectives?) and speed (how quickly?). Also track discovery: How much clearer are your wants and don't-wants getting? When do people bypass the system? Don't wait for monthly reports to know something's wrong. Good metrics show problems while they're small fires, not raging infernos.
  • PRACTICING WISER

    The WISER approach works best when you approach implementation with the same mindset as the process itself: practical, focused, and ready to discover what actually works. Don't turn implementation into another bureaucratic exercise.

    Start Small

    Apply WISER to one process before rolling it out more broadly. Quick wins build credibility and teach you what actually works in your environment. Don't try to boil the ocean—heat up a cup of water first.

    Expect Your Understanding to Evolve

    Plan for your approach to change as you learn. This isn't scope creep—it's scope clarity. You'll discover better ways to apply WISER as you use it. Let each iteration teach you something about what works in your context.

    Have a Bias Towards Action

    Even while questioning every step in the early phases, if you spot an issue that can be quickly fixed, do it immediately. Quick wins validate the WISER mindset and help you learn what improvements actually stick.

    Show, Don't Tell

    Demonstrate results rather than selling theory. Let the improved process speak for itself. Nothing convinces skeptics like measurable improvements. PowerPoint decks don't fix broken processes.

    Build to Learn What Your Team Needs

    Assemble people who represent the functions needed, but expect the team composition to evolve. Small teams move faster. One person can play multiple roles when needed. You'll discover the right team structure through doing the work.

    Clarify Ownership Before You Begin

    Automation starts with intent. Assign human ownership to every objective. AI can move fast, but if no one is steering, speed just gets you lost faster.

    Embrace Play and Discovery

    Create an environment where people feel safe to experiment and admit they don't know. Psychological safety enables teams to question assumptions, suggest radical ideas, and discover what actually works. When fear drops, innovation soars.

    Learn Through Making

    Expect some things to break when implementing changes. Set clear expectations that fixes need to come quickly. Fast failures with faster fixes teach you what actually works better than slow, perfect rollouts. The real world is your laboratory, not the whiteboard.

    Allocate Real Time

    Part-time attention produces part-time results. Give the team dedicated time to focus and discover what works. Process improvement as a side hustle rarely teaches you anything useful.

    Adjust as You Discover

    The WISER process itself should evolve based on what you learn about your organization. Don't follow it rigidly if a step isn't adding value. Practice what you preach—simplify WISER itself when needed.

    ASSEMBLING THE TEAM

    The WISER Method doesn’t require a large team, but it does require the right roles to be filled. These roles represent core functions—not job titles—and can be distributed across multiple people or owned by one capable individual. The goal is to make sure each responsibility is covered so that improvements are informed, coordinated, and help the team discover what actually works.

    Sponsor

    Responsibility: Makes final decisions on what to change, keep, delete, and automate.

    • Should have authority to implement changes without endless approvals
    • Accountable for the outcomes of the WISER implementation
    • Ensures every objective has a clearly named human owner before automation proceeds
    • Needs to balance immediate improvements against longer-term needs
    • Must be willing to make tough calls based on evidence, not politics
    • Expects objectives and approaches to evolve as the team learns what actually works

    Architect

    Responsibility: Visualizes, simplifies, and communicates complex processes and decisions.

    • Creates process visuals, blueprints, and flows that are easy to understand
    • Translates jargon and complexity into plain, accessible language
    • Captures not just what was decided, but why and what was learned—ensuring future clarity
    • Helps the team see connections, gaps, and opportunities others might miss

    Sage

    Responsibility: Provides deep knowledge about the system or process being improved.

    • Knows the history of why things were built a certain way
    • Understands the unwritten rules and exceptions
    • Can explain what has been tried before and why it failed
    • Doesn't need to be the most senior person - just the most knowledgeable

    Scout

    Responsibility: Gathers information and clarification when needed.

    • Skilled at asking good questions and getting straight answers
    • Has access to people across the organization
    • Persistent and resourceful in finding information
    • Able to translate technical or domain-specific information for the team

    Smith

    Responsibility: Implements technical changes, automation, and system integration.

    • Translates process improvements into technical solutions
    • Embodies the builder mentality—fixing things rather than creating more process
    • Rapidly prototypes and iterates to discover what actually works in practice
    • Understands both the technical landscape and business needs
    • Helps transform team members from process followers to process builders

    Sentinel

    Responsibility: Tests improvements and confirms they meet objectives.

    • Verifies that changes actually solve the problem and helps the team learn what works
    • Thinks from the user perspective
    • Identifies potential unintended consequences
    • Ensures the solution works in real-world conditions, not just theory

    Guide
    Responsibility: Drives the WISER process from start to finish, creating an environment that fosters honest questioning, play, and creative experimentation.

    • Aligns the team to objectives while maintaining psychological safety
    • Balances quick wins with long-term transformation
    • Creates spaces where challenging assumptions is encouraged
    • Removes roadblocks and prevents bureaucracy from creeping back
    • Holds space for both momentum and reflection when needed
    • Helps the team embrace that objectives and methods will evolve through discovery

    THE FUTURE BUILDER

    WISER isn't just about fixing processes—it's about transforming people. As organizations adopt these principles, employees transform from process followers to process builders. Instead of being cogs executing inherited procedures, they become architects of continuously improving systems. The future belongs to builders who question, simplify, and discover what works through making—not those who merely follow predetermined plans.

  • OUR NEWSLETTER

    written by and for people who build things