Retained and immediate mode

At the core of the OODA loop is the concept of a model. To create space for exploring it in depth, we’ll make a tiny little digression back into — you guessed it! — graphics rendering technology.

With my apologies to my colleagues — who will undoubtedly make fun of me for such an incredibly simplified story — everything you see on digital screens comes from one of the two modes of rendering: the immediate or the retained modes.

The immediate mode is the least complicated of the two. In this mode, the entirety of the screen is rendered from scratch every time. Every animation frame (remember those from the jank chapter?) is produced anew. Every pixel of output is brand new for each frame.

You might say: yeah, that seems okay — what other way could there be? Turns out, the immediate mode can be fairly expensive. “Every pixel” ends up being a lot of pixels and it’s hard to keep track of them, yet alone orchestrate them into user interfaces. Besides, many pixels on the screen stay the same from frame to frame. So clever engineers came up with a different mode.

In retained mode, there exists a separate model of what should be presented on screen. This model is usually an abstraction (a data structure as engineers might call it) that’s easy to examine and tweak and it is retained over multiple frames (hence the “retained” in the name). Such setup allows for partial changes: find and update only the parts of the model that need to change and leave the rest the same. So, when we want a button to turn a different color, the only part that has to be changed is the one representing the button’s color.

Both modes have their advantages and disadvantages. The immediate mode tends to need more effort and capacity to pay attention to the deluge of pixels, but it also offers a fairly predictable time-to-next-frame: if I can handle all these pixels for this frame, I can do so for the next frame. The retained mode can offer phenomenal benefits in saving the effort and do wonders when we have limited capacity. It also yields a “bursty” pattern of activity: for some frames, there’s no work to be done, while for others, the whole model needs to be rejiggered, causing us to blow the frame budget and generate jank.

This trade-off between unpredictable burstiness and potential savings of effort is at the crux of most modern UI framework development. The key ingredient in this challenge is designing how the model is represented. How do elements of the screen relate to each other? What are the possible changes? How to make them inexpensive? How to remain flexible when new kinds of changes emerge?

The story of Document Object Model (DOM) can serve as a dramatic illustration. Born as a way to represent documents at the early beginning of Web, DOM has a strong bias toward the then-common metaphor of print pages: it’s a hierarchy of elements, starting with the title, body, headings, etc. As computing moved on from pages towards more interactive, fluid experiences, this bias became one of the greatest limiting factors in the evolution of the Web. Millennia — hell, probably eons — of collective brain-racking had been invested into overcoming these biases, with mixed results. Despite all the earnest effort, jank is ever-present in the Web. Unyieldingly, the original design of the model keeps bending the arc of the story toward the 1990s, generating phenomenal friction in the process. 

In a weird poetic way, the story of DOM feels like the story of humanity: the struggle to overcome the limitations imposed by well-settled truths that are no longer relevant.

Micro and macro jank

If our team’s OODA loop runs just a tiny bit slower than the clock of the environment, we will generate a flurry of micro-jank — many incidents that are so tiny, we can barely notice them. Unlike with machines, our collective resilience will helpfully wallpaper over these thousand cuts. However, as we’ve learned before, an incident of jank creates a deficit for the next cycle. It is fairly easy to see that this deficit continues to accrue over time. So the micro-jank grows into larger problems over time.

This larger problem usually manifests as macro-jank: a big reset that is clearly felt by everyone in the organization. The whole team seizes up and briefly stops listening to the environment’s clock, focusing inwardly to sort out their own mess.

In my experience, this phenomenon has an easily recognizable marker. A team that accrues OODA deficit tends to fall into this gait of periodically changing things around to see if their troubles will go away. However, because the source of the deficit remains unexplored, the rearranging of furniture rarely results in lasting change. Be it a dramatic shift in priorities, changing of leadership, or a reorg — it’s at best a temporary fix, quickly leading back to deficit accrual.

One of my go-to examples of this sawtooth pattern is “leads reset.” As the team forms, a small group of leads is organized. At first, these leads operate as an effective unit, providing valuable direction and insights on priorities to the rest of the team. However, as the time goes by, leads discover gaps in their knowledge, and pull in more people onto the leads group. Sometimes this happens as a result of a team growing, but often, the breadth of the challenge is such that a small group of people simply can’t grasp it fully. Plus, it feels important to be in the leads group. After a little while, the group of leads becomes large and unwieldy. Effective conversations yield to bickering and eye-rolling. Leads themselves become disheartened, which percolates throughout the team. So what happens next? As you’d probably guessed, a new, smaller group of leads is formed — until the next reset.

Having been part of these groups and an organizer of them, it always struck me as weird: why is it that we keep trying this same method to organize a leadership structure, over and over again? When a question like this pops up, it’s a good sign that the OODA deficit is being accrued.

Can macro-jank happen spontaneously, without first accruing micro-jank? It seems possible. Like, let’s imagine a severe and rapid environment change… oh wait, we don’t have to. It’s right outside. The COVID-19 pandemic will likely be a subject of many studies as a dramatic disruption of our environment. But was it truly an unexpected event or rather an outcome of micro-jank accumulating over a long period of time? How might we reason about that? To get there, we need to take a closer look at the nature of the OODA loop.

OODA, unrolled

Putting jank and the OODA loop next to each other, it’s hard not to see the similarity. Both have two timelines racing against each other. Both describe one timeline trying to go a bit faster than the other — and there’s one timeline that consists of a repeating sequence of steps.

The question that got me excited was: “What does jank look like for the OODA loop?” To answer it, I did some light reframing to express the OODA loop as the timeline view that we’ve learned from rendering animations.

In this timeline view, the environment’s OODA loop becomes the ticking clock. Within each tick of this clock, we fit the familiar pipeline-like process: observe, orient, decide, act.

This setup is not exactly the same as having two independent nested loops, interacting with each other. However, since we’re most interested in situations where the nested loops are closely matched, this simplification works well enough. Here, the environment sets the pace and we try to match it. With each tick of the clock, the next round begins.

In this framing, the OODA jank is the situation when the cycle of the inner OODA loop is taking longer than the one of the environment. 

Since I’ve just concocted a different way to look at the OODA loop, I might as well add another twist. Unlike in Boyd’s original military context, OODA jank is not lethal for most organizations. It is something that happens commonly, perhaps many times over.

Team jank is not great news, but most of the time it’s not existential, either. Deadlines get missed, but things still get delivered. People are late to meetings, but they do show up. Product launches get delayed, but most often, still happen at a later date. Human systems aren’t mechanical. They tend to be more resilient to jank. When rendering Web pages, a late-to-render animation frame is completely dropped. In organizations, being late just means reduced effectiveness, a miscalculation and wasted energy.

As a result, organizations typically feel jank not as one specific incident, but rather as cumulative effects of multiple instances. Perhaps we can use this newly-minted framework to dig into these effects?


I first learned about jank when I joined the Chrome team. It’s a weird slang word with multiple meanings,  so I am going to use a narrower definition, custom-crafted just for this narrative. To get there, I will make a brief detour into the land of rendering Web pages. Hold on to your hats.

Suppose you are visiting a site. I’ll be the browser in this story. You just clicked on a button, and I need to play out a lively animation as a result. Like humans, browsers are mesmerizingly complicated, but at a very high level, the animation is a sequence of frames — pictures of the intermediate states between its beginning and end. Each frame is rendered — that is, created on demand in a very brief moment of time. For example, to play out an animation at a common-for-computers rate of 60 Hz (that’s 60 frames per second), I have just under 17 milliseconds to render each frame.

Rendering itself is a multi-step process, usually called a pipeline (does this start to remind you of something?) To produce a frame, I must go through each step in the rendering pipeline. Think of it as a clock that ticks every 16.667 milliseconds. If I was able to fit all the steps between the two ticks, I have a frame of animation that I can show to you. Yay!

However, if going through the rendering pipeline takes longer than that, the next tick will arrive before I have the frame ready. Bad news. Despite all the work that I’d done, you won’t see this frame. It’s dropped. Worse news: because I had to finish all the steps (those are the pipeline rules), I accumulated a deficit — my work on the frame that follows begins with the negative time balance. For example, instead of 16.667 milliseconds, I might only have 12. What’s the likelihood that this frame will get dropped as well? Pretty high.

As a user, you will see this phenomenon as “jank”: instead of a smooth animation, it’ll look like a stuttering janky mess. Put very dryly, jank is the observed effects of a regularly scheduled pipeline-like process not fitting into its allotted time budget.

Wow. That is very dry. Let’s see if we can make it a bit more useful by applying what we learned here to the OODA loop. Let’s unroll the OODA loop.

The OODA Loop

One of the lenses for which I tend to reach frequently is the OODA loop. First articulated by John Boyd in the context of combat, it’s found its way into various other spheres of strategic thinking. The way I hold it is probably different from how The Mad Major intended, because I apply it in non-confrontational contexts. Here’s the basics.

Conceptually, our interaction with the environment outside can be viewed as this continuous cycle of observing, orienting, deciding, and acting — also known as the OODA loop.  

When we observe, we try to gather information about the environment. What is happening? What are the circumstances? What are the changes? Trends? What are the constraints?

Then, like clockwork, we move on to orienting, or making sense of what we’ve observed. We try to look at all of the existing information we might have, smash it with the new one, and synthesize a model of what’s happening. 

Once we’ve convinced ourselves that this is indeed the model, we decide. We try to roll the model forward in time and predict what will happen next, forming our hypothesis for the final step. 

Once we have the hypothesis, we act within the environment. The all-important feedback loop takes us back to the first step. Acting is just a test of our hypothesis, and we need a way to keep refining that hypothesis. 

So we jump back into observing. What happened after we acted? How did the environment react to it? What does that tell us about it? And on we go, cycling through the OODA loop.

One significant part that I often see missed is that there are actually two interrelated loops. As mentioned above, the environment cycles through a loop along with us. Suppose that you and I are playing a simple turn-based game. Applying the OODA loop lens, I am part of your environment. It’s easy to see how both you and I are cycling through two loops. You observe my actions, I observe yours. We both orient, decide, and act based on the actions of each other. Being turn-based, our game synchronizes our OODA loops. I can act only after you act and so on. Now, imagine that you could take five turns while I could only take one? That would give you a massive advantage. You’d be running … err… loops around me.

This is a valuable insight that’s not easy to grasp when just looking at a picture of a loop. Outside of this cyclical sequence of steps is another loop — the one of the environment.  

If I am cycling in lockstep with the environment, I never have to worry about keeping up. I have the advantage if I am cycling much faster — I can be five steps ahead, anticipating what comes next like a magician. Of course, if my OODA loop cycle is a few times slower than that of the environment, I am like that sloth from Zootopia, hopelessly out of touch with what’s happening: the environment is zooming past me.

It is my experience that these situations are rare and I am not going to spend much time considering them. Instead, I want to study the situation where most organizations find themselves: the two loops cycle at nearly identical speeds, and the organizations struggle to get their OODA loops to go faster. Which brings us to the concept of jank.

Enumerating constraints

The process of inferring a set of constraints with which to communicate a strategy can get pretty overwhelming, so I made this handy little framework for enumerating them. It’s not a complete taxonomy, but hopefully it’s generative enough to get started.

When looking for constraints, I use a riff on Lawrence Lessig’s pathetic dot framing. Think of constraints as loosely bunched into four different forces that press from every direction: capabilities, rules, norms, and incentives. Their sum is what defines the game being played.

From the bottom, we are supported — and limited — by our capabilities. These are our team’s strengths and weaknesses and understanding them greatly helps us assess our potential. What is the team’s mix of senior and junior members? How do their collective skills map to the challenge at hand? What are particular things that make this team unique? What are the known failure modes the team might be susceptible to?

At the top, there are rules that are imposed on us by the environment. These could be related to funding or deadlines, or priorities of the larger organization. Market and ecosystem forces also fit in here. A good way to spot these kinds of constraints is to look for things that we perceive as happening regardless of our attempts to control them. These are our threats and opportunities.

Forming the vertical axis, rules and capabilities are in tension with each other. Usually, one acts as a limit to another, establishing dynamic equilibrium. If there’s no such equilibrium between these two, it’s not a game. When listing out rules and capabilities, make sure that the sets feel roughly evenly matched. Otherwise, we might be deceiving ourselves about the nature of the game.

The horizontal axis captures constraints that reflect dynamics within the team. Just like with the game axis, these forces are in tension. If they are mismatched, there is no team.

On one side, there are incentives. Incentives are what drives individual agency within the team. In this bunch, there are constraints that define the reward system for the team. How do the individuals know if they are succeeding or failing? How do they know whether they are progressing along their intended career arc? Are they making the kind of impact that is aligned with the team’s objectives? This one can be tricky. For example, in larger organizations, the incentive structure is commonly imposed centrally, which means that the team leads might find that their objectives are often at odds with that structure (like the “I don’t want to work on this project, because there’s no promo for me in it” case). In such a case, those are better viewed as rules (the top-down arrow), rather than team incentives.

On the other side, there are norms that bind us together. “Bind” is the operative word, because the thing that binds us always acts as a constraint. Cultural norms define what’s acceptable and not acceptable within the team. Norms are tricky, because “culture” has developed a bit of a duality in modern organizations. There’s the norms that we’d like the team to have and there are the norms that exist. If we use this exercise to evangelize the former, we might arrive at communicating a strategy for some other, imaginary team. For example, if we aspire to triage bugs within 24 hours as a team, this is not a constraint. Instead, the constraint is the actual time it takes today — our norm. 

As we enumerate constraints, a picture of the playing field emerges. If our norm is that it takes us 7 days to triage a bug, yet one of the looming threats is our customers consistently finding our support levels lacking, we look to the counterbalancing constraints. For example, there might be incentives or capabilities we underutilize that we could lean onto — and this thinking process leads to generating various plans to accomplish that. Add a solving diverge-converge exercise to pick the best alternative, and now we’re cooking with gas. Shifting from plan-based strategies to constraints-based strategies creates more cognitive load on the team — planning becomes a much more distributed process — but it also dramatically increases the team’s capacity to navigate flux. More importantly, understanding constraints creates a space for team leaders to examine them and mutate them to intentionally change the game.

Communicating strategy as constraints

A click up from a plan is communicating strategy as constraints. When plans are constantly stymied with change, we start seeking the means to describe this change in terms of invariants. We climb up the abstraction ladder to see if there’s less flux up there. Constraints are usually what we encounter next.

An easy way to grok constraints-based strategy communication is to look at sports. Sports are games with well-defined constraints: what’s allowed and not allowed, how one is rewarded or punished while playing. Like structural beams of a house, constraints frame the problem space.  If the constraints are stable and well-rounded, we humans are exceedingly good at discerning, adopting them — and adapting to them. Constraints also serve as generative sources of plans. Instead of having just one plan that is created each time, a good coach will have a whole playbook of plan templates drilled into their teams. When the game begins, there is no one Big Plan: instead, plans emerge and evolve from the playbook’s templates. My friend Alex Russell had this really nice “beat saber block” analogy. When the team communicates their strategy in terms of constraints, plans — like blocks from that VR game — materialize a short distance out, while being informed by a larger arc of the story, framed by constraints.

That’s what makes communicating strategy as constraints so much more effective than producing plans — and also a lot more challenging. To communicate them, a leader needs to first devise a set of constraints that capture the nature of the game they want to be played. This requires strategic awareness, rigor, and patience. Though my inner game designer momentarily rejoices at the opportunity, it’s incredibly difficult in my experience. Instead of inventing a new game, this effort is mostly about inferring some semblance of stability out of the churning stew of the environment. As a result, most constraint sets come out dismally misshapen in their first iteration.

Usually, they are leaky. For example, imagine that I provided a constraint that the score is only awarded when the hockey puck crosses the goal line, but forgot to specify the size of the goal. It is fairly easy to see how an overly clever team might be tempted to bolster their defenses by shrinking the goal to be smaller than the puck — this may or may not be a true story from my childhood.

They also tend to be either too specific or too broad. Go too specific, and you’re back in the plans territory. Go too broad, and the constraints are no longer useful. In one of the dimmer moments of my career, I once proclaimed that the goal of our team would be to “not screw it up” in the next year. Great! What does that even mean, oh fearless leader?! 

An experienced leader — just like a seasoned coach — usually carries a playbook that allows them to sketch out a decent initial set of constraints for any team. However, I found that getting constraints to the point where they’re stable and well-rounded is something that can only happen by the team collectively participating in refining the rules of the game by which they play.

A strategy and a plan

A colleague asked me this great question: “What’s the difference between a strategy and a plan?” Put very simply, a plan is one way to communicate a strategy. But you know me, I want to get at the subtlety of what this implies.

First up, semantics. I found that when people say “strategy,” they usually mean one of two distinct things. One is the business strategy, which is a whole discipline about the means to obtain durable differentiating business outcomes. This field is well staked-out and I don’t want to trespass there. The other one has a more generic meaning, as in strategy games or strategic thinking, which is usually associated with seeking some long-term outcomes through a series of short-term actions. That’s the one I want to play with.

Applying this definition, most of us operate with some sort of strategy in mind. Unlike that forgetful fish from Finding Nemo, we wish for what we did today to contribute to some longer-term objective. When we believe that it didn’t, we feel like we wasted our time. When we believe that it did, we feel more content: things are going our way.

Working as a group, our good fortune depends (among other things) on how well our actions align toward a common goal. This alignment is an emergent phenomenon: if we end up pulling all different directions, we might be trying really hard, yet make no progress toward the goal. Conversely, we race toward it when we’re aligned. A team leader’s key challenge is making sure that a) there is a high degree of alignment and b) the team’s common goal matches the desired outcomes the leader has in mind. 

Somehow, the leader needs to ensure that when team members act in the short term, their actions add up to positive momentum toward where the team is asked to go. Somehow, they need to communicate their strategy: transfer the necessary parts of their strategy from their minds to the minds of the team members.

Plans are an ancient and probably simplest method to do this. Outline all the steps that the team needs to take to get to their objective and communicate them in a resonant way — usually many times over — until everyone on the team knows what they are. Plans are amazing, because all we need to do is follow the steps and if we do, we know we’re going in the right direction. They are exceedingly effective in environments where the validity of the strategy can be easily verified. For example, if I walked through a maze and wrote down all the turns, you can follow my plan and know for certain whether it works. From there, a previously treacherous puzzle becomes a slightly annoying routine for everyone who follows the plan. In such a setting, the plan is the strategy.

In more fluid environments, plans tend to rapidly lose their effectiveness. When we don’t know if the maze stayed the same since the last time we traversed it, communicating strategy needs to mature beyond plans. The leader has to transfer not just a particular solution to a particular maze, but the means to solve any maze in a consistent and safe way. To meet their challenge of alignment, they need the team to continue making progress toward the long-term outcome when the circumstances change: collectively inching toward the exit even if the walls in the maze shift and mutate.

So, when we’re looking at a strategy artifact, here are some questions to reflect on. If it looks like a plan, are we operating in a stable, predictable environment? Can we quickly validate that this is the right plan? If so, we’re probably set — let’s go. Otherwise, we are better off stepping back and investing a bit more time into considering how might we share our mental model of the environment with the team to empower them to create and change their plans on the fly in a way that’s still compatible with our strategy.

Slow down

I wrote this one primarily for myself, though I believe it’s good advice for anyone who’s ever found themselves in a leadership role in today’s work environment. Here it is: slow down.

I am not talking about taking some time off, going on a digital vacation, or just relaxing a bit in the evening and doing some light reading. Those things are great and important parts of our lives all in themselves. When I say “slow down,” I mean slowing down at work: to remain surrounded by work, but take time to reflect on what’s happening. When I was developing my self-work routine, I had this metaphor of a riverbank that might be useful here. Slowing down means stepping out of the turbulent river of our daily work and sitting on the riverbank for a little bit. Pause. Look around. Are we still going where we want to go? Or are we being carried by the river?

Think of it this way: we’ve learned to go fast, we’ve honed our effectiveness, ways to put the pedal to the metal. Today, our problem is not that we are lazy. It’s that our undercurrent of achieving is too strong. Through this lens, procrastination can be a shaming word for having patience to let the solution reveal itself. And when we start getting worried that we’re not achieving fast enough, we get further trapped in the churn of the river. 

In Adult Development Theory, there’s this notion of fallback. A metaphor for it that I really like is that our minds are houses with rooms, where some rooms become inaccessible during fallback. It’s like we know our house has them, but we just can’t find our way to them. So while in fallback, if we want to go to the Strategy room and do some long-term thinking, we keep finding ourselves in the Tactics room, covered in glitter and glue of the short-term fixes. There are many causes of fallback, and in my experience, the achiever stress is not an uncommon one.

As we fall back, our perspective narrows. We can no longer see options and opportunities that are locked away in those now-inaccessible rooms, and it feels right and natural to just keep doing what we’re doing. A deadline is coming up, so of course we need to jump on that. Our colleague needs to meet, so yes, we’ll find the time. And as we just keep on swimming, we find our schedules getting busier and pace continuing to rise. We keep going faster and faster. In the moment when we need to open some space to think, taking an even little pause feels like the wrong thing to do: who’s going to do all this work?

Those of you who work with me know that I have my late Friday afternoon blocked off for reflection. I have three questions that I pose for myself. They are loosely: 1) what did I do this week? 2) am I losing sight of the big picture? and 3) what might I change in how I conduct my next week? This is my time to slow down. No matter how high the fires are, and how urgent the pings to meet, I try to spend this time sitting on the riverbank. Sometimes it doesn’t work, though over time, I am realizing that the trick is to keep trying. Keep trying to slow down.

The structure of a principle

We had a bit of weather recently, and while waiting for electricity to come back on, I found myself flipping through the pages of The Timeless Way of Building by Christopher Alexander. I was re-reading the chapter about the structure of patterns when something clicked. I realized that patterns and well-learned organizational principles are very similar in structure.

Principles are a big thing in today’s organizations. Most want to have them, yet few get to benefit from them. It is fairly easy to list out a bunch of “things we wish to be true”. But how do I make them actually useful to my team? A sound principle is like a pattern in this regard: it helps navigate a tension that is otherwise difficult to grasp. A principle is only an aspiration if it simply points at the desired destination without doing the hard work of capturing the challenges that will make reaching this destination difficult. Put it differently, if a principle doesn’t wrestle with some tension, it’s probably not a principle.

Borrowing from Alexander’s playbook, my guess is that a sound principle will have this structure: it will begin with the context, describing the situation in a way that is resonant to the team. Then, it will point out the forces that are present within this context — these forces are usually in tension with each other. Then, it will provide guidance (Alexander calls it “configuration”) on how to navigate this tension. Another thing that stood out for me was Alexander’s pursuit to get the name of the pattern right. Similarly, the few words that capture the nature of the principle will become the team’s shorthand, the intuitive handle. It’s worth a bit of extra wordsmithing to make that handle fit like a well-built tool in the team’s collective minds. 

To play with this idea, I decided to use a principle from an org I used to lead. We dubbed it “Treat 1P like 3P.” It was a simple phrase, but it seemed to have been useful: it helped resolve conversations about priorities, serving as a planning and strategy tool. Let’s see if I can retcon that principle into the structure above.

We’ll start with framing the broader context.

Our team ships a developer surface to both internal and external customers. We are at the early stage of our journey, where most of our customers are internal, but we expect the ratio to shift toward external customers over time. The internal customers sit right next to us. We know their workflows and tools. We work at the same company. We  can talk easily to them and partner with them as well as coordinate our plans. The external customers work at other companies, and we often have no easy way to communicate with them. At the start, we only have some guesses about what tools and workflows they might use, but we know for sure they will be different from the custom stack of our internal customers.

Next, we point out the forces that operate within this context. There are two: availability bias and technical debt.

Availability bias. Proximity, familiarity, and general alignment of values creates an incentive toward first-party customers. The path of least resistance leads to shaping our developer surface closely to fit the tools and workflows of internal customers.

Technical debt. Knowing that the internal/external ratio will shift over time, we need to be cognizant that overfitting to the needs of internal customers will incur the cost of painful future migration to a more flexible architecture.

Now that the forces are defined and it’s fairly easy to see how they are in tension, let’s provide guidance on how to navigate that tension.

We recognize that the availability bias is a short-term force, and technical debt is a long-term force. We expect that the short-term force will generally prevail in day-to-day decisions, so we lean a bit toward the long-term force. To do so, we treat our internal customers as if they were a kind of an external customer. We avoid embedding any special knowledge of the internal customer-specific stack. We do research on other potential stacks and ensure that our architecture is flexible enough to support them.

Finally, the handle. Within our team, we called internal customers “1P” and external customers “3P,” so “Treat 1P like 3P” ended up working nicely: it was easy to say and remember while conveying the gist of the guidance.

Looking back, this is not how I structured the principle. Instead, it was just a brief paragraph of words beneath the title. But now that I’ve gone through the exercise, I am noticing something interesting: I want to argue with my past self about the context and the nature of the forces that I was seeing back then. This is probably the most powerful part of structuring principles like that: it allows your team to examine the principle, understand how you arrived at it, and help you make it more sound by presenting their own perspectives.