Honey Vig Web Developer Ajax,Jquery, ASP, PHP, dotNET

The Top 25% Isn't a Ranking. It's a Definition.

noreply@blogger.com (H) — Mon, 27 Jul 2026 08:54:13 +0000

The idea that anyone can be in the Top 25% is not some crazy AI-inspired new math.

Just ask any hiring manager what someone’s needs to do to be considered in their Top 25%, and you won't get a percentile. Nobody answers, "outperforms three-quarters of their peers."

Here’s one response.

A top 25% performer consistently delivers results that exceed expectations, not just meets them. They don't need constant direction. They solve problems before they become crises. They make everyone around them more effective, and if I lost them, replacing them would be difficult.

It turns out the Top 25% is a floor, not a ceiling. And when viewed that way, it's a floor most people can reach in the right job, with the right manager, and in the right situation.

Todd Rose, who wrote the End of Average, agrees. In his book he tells a story about how the Air Force had a problem in the late 1940’s: its planes kept crashing because the seats were designed to fit the "average pilot" based on measurements of thousands of airmen. But after measuring 4,063 pilots on ten body dimensions not one single pilot was average on all ten. The fix wasn't better pilots – it was adjustable seats.

Rose’s conclusion for hiring: there is no average person. People are jagged – exceptional on some dimensions, ordinary on others – and their performance is not a fixed property they carry from job to job. It is created, or destroyed, by context: the actual work, the manager, the team, the pace, the stretch.

So while what follows is a reasonable definition of the Top 25%, finding people who fit this “adjustable seat” requires a different way of thinking. “Moneyball for HR!” is the solution.

Ability in relationship to fit drives motivation to excel. Defining the fit factors is the key for better hiring decisions.

One Reasonable Definition of the Top 25%

Delivers exceptional results. Regularly exceeds the performance objectives of the role. Produces higher quality work with fewer mistakes. Can be trusted with the toughest assignments.
Learns faster and adapts quickly. Masters new tools, products, and processes quickly. Adapts when priorities change. Doesn't need to be told twice.
Takes ownership. Acts like the business is theirs. Solves problems instead of escalating every issue. Makes decisions with good judgment.
Makes the team stronger. Helps others succeed. Shares knowledge. Raises the performance of the entire group.
Improves the business. Finds better ways to do things. Eliminates waste. Creates measurable improvements in productivity, quality, customer satisfaction, or profitability.
Can handle bigger challenges. Performs well beyond today's job description. Is promotiable.

Define the Job and Situation Before Defining the Person

Finding people who meet this standard of excellence starts by defining the actual job, the actual situation, the actual resources, the actual team, the true corporate culture, the actual company politics, the intensity of the situation and the hiring manager’s leadership style.

And the process must be bi-directional. All of this must be revealed pre-hire if you want to achieve Top 25% performance post-hire. Given this, you need to source, screen, recruit, hire and manage people who fit this true description of the job. This used to be really hard, pre-AI. Now it’s not.

In fact, we’ve built “The Perfect Hiring System to Hire the Top 25%” and we’re giving it away as a Claude skill.

It all starts with this simple question when opening a new job requisition, “What does the person in this job need to do to be considered a Top 25% person?”

The Perfect Hiring System changes the entire hiring ecosystem at less cost with better results.

In turns out top 25% performers aren't defined by what they know. They're defined by what they accomplish and how they accomplish it.

Back to School Trends: What Sold in 2025

noreply@blogger.com (H) — Mon, 27 Jul 2026 08:49:29 +0000

Back-to-school 2025: school uniforms up 231% MoM and backpacks up 180%, per Shopify data. See top categories by region and what's trending down.
A backpack in a circle on a blue panel on a light blue background.Starting each July, families across the US flood stores—online and offline—to gear up for a new school year. This year, Shopify sales data shows which back-to-school categories are most popular. Explore which trending items saw the biggest jumps, which categories lagged behind, and what the differences across regions might reveal about changing school culture.
Back-to-school sales trends: All US
Product category MoM sales* School uniforms +231% School backpacks +180% Lunch boxes & totes +174% Bulletin boards +81% Stickers & sticker machines +80% Calculators +56% Folders +34% Pencils +27% Water bottles +24% Planners +19% Hand sanitizers & wipes +19% Notebooks & notepads +17% Art & craft paper +15% Laptops +11% Sticky notes +11% Binders +11% Pens +8% Sports uniforms +7% Book covers -1% Markers & highlighters -8%

*Shopify sales data comparing July 2025 to June 2025.

The back-to-school categories that saw the greatest spend in July were backpacks, sports uniforms, water bottles, lunch boxes and totes, pens, and notebooks. Categories with the most growth compared to the previous month were school uniforms (231%), backpacks (180%), and lunch boxes and totes (174%).

School uniforms, while a smaller category in total sales, posted the most dramatic month-over-month growth at +230.6%. This aligns with broader market trends: National Center for Education Statistics data shows that 18.8% of public schools required uniforms in 2019–2020, with requirements more common at the elementary level (21%) than in high schools (12%). Recent projections anticipate the school uniform market to reach a 6.1% compound annual growth rate by 2031, signaling stable, long-term interest.

Especially in uniformed environments, backpacks and lunch boxes play a key role beyond function in student identity—often serving as one of the few forms of self-expression. Water bottles, similarly, have become key accessories where students can showcase personal style—a small but important outlet for identity.

While water bottles, notebooks, and pens were among the most popular spending categories, month-over-month increases were more moderate—24%, 17%, and 8%, respectively—signaling the popularity of these purchases beyond the back-to-school season.

The only back-to-school items that saw month-over-month sales decline were markers and highlighters (8%), and book covers (1%). This decline could indicate that they aren’t requirements on school supply lists, or it could reflect increasing reliance on digital tools, like e-readers and styluses, particularly in higher grade levels.

Build your dream online store today

Join the ranks of the world’s best online stores with Shopify’s powerful tools and features. With the highest-converting checkout, Shopify stores sell more products, lower your costs, and save you time.
Learn more
Back-to-school sales trends by region
Midwest

The top-selling back-to-school item in the Midwest was sports uniforms, followed by water bottles, backpacks, pens, lunch boxes and totes, and notebooks. Stickers and sticker machines saw a more significant month-over-month sales increase compared to other regions, increasing by 174%. Calculator sales declined compared to the previous month, with an 11% drop—the only region to see a MoM decline.
Northeast

The top-selling back-to-school item in the Northeast was sports uniforms, followed by school backpacks, water bottles, pens, and lunch boxes and totes. Sports uniforms saw the strongest MoM growth in the Northeast (25%), while bulletin boards had the smallest MoM growth compared to other regions—24% compared to 104% in the Midwest, 86% in the South, and 49% in the West Coast.
South

The top-selling back-to-school item in the South was backpacks, followed by lunch boxes and totes, water bottles, sports uniforms, pens, and notebooks. The South recorded the strongest MoM growth in water bottle sales (35%), as well as calculator sales (124%), compared to other regions.
West Coast

The top-selling back-to-school item in the West Coast was water bottles, followed by sports uniforms, backpacks, pens, lunch boxes and totes, and notebooks. Even though it accounted for the second-greatest overall sales, sports uniforms sales declined MoM by 14%, perhaps indicating that purchasing starts even earlier compared to other regions.

Designing With Uncertainty: How AI Supercharges Probabilistic Thinking

noreply@blogger.com (H) — Mon, 27 Jul 2026 08:48:00 +0000

In a world where AI is informing more design choices, it’s easy to mistake predictions for certainties. This article introduces Probabilistic Design, a mindset that allows UX and product teams to accept uncertainty, decipher AI outputs with nuance, and make smart, adaptive decisions.

In 2024, an Air Canada customer asked a chatbot about bereavement fares. The bot confidently gave him a refund policy that didn’t exist. The airline refused to honor it. A tribunal ruled in the customer’s favor. The bot hadn’t decided anything; it had predicted an answer based on patterns in its training data. The company treated that prediction as policy.

This is the risk at the heart of designing with AI today: probabilistic systems wrapped in deterministic interfaces. The AI offers a guess, the interface presents it as truth, and the user, or the organization, acts on it.

Humans are wired for deterministic thinking. We prefer to believe that past actions determine future outcomes. Flip a coin 999 times and get heads every time, the deterministic mind assumes the coin is rigged. The probabilistic mind accepts that the 1000th flip could still go either way. That second mindset is harder to hold onto, but it is exactly what designers need right now.

Products operate in complex, nonlinear environments, and AI is accelerating that complexity. When designers and product teams treat AI outputs as the answer rather than one of many possible answers, they build fragile experiences, and in some cases, like medical diagnostics or financial forecasting, genuinely dangerous ones.

This article is a practical guide to designing probabilistically with AI as a partner. It is about using AI to sharpen your thinking rather than outsource it, accounting for model bias, human sentiment, and perceived risk along the way.

Probabilistic Thinking + AI

Most questions we ask AI do not produce binary answers. They produce probabilities based on patterns in data. If you ask, “Do aliens exist?” the answer will be somewhere between plausible and uncertain. Scientists consider life elsewhere in the universe likely, but without any concrete evidence, we cannot confirm it. The answer doesn’t resolve the question; it frames it as a probability.

Designers should read AI outputs the same way. They are signals, not conclusions, possible outcomes that have to be interpreted within the context of product goals, user behavior, and business constraints.

Many digital products already work this way. Netflix doesn’t know you’ll enjoy Superstore because you watched The Office; it estimates the probability and surfaces the title accordingly. The interface is responding to a prediction.

Design decisions can follow the same logic. AI models can combine behavioral analytics with research insights to estimate the likelihood of certain outcomes, and those probabilities can act as a yardstick for design strategy. Consider a scenario where analytics suggest a 60% versus 90% confidence that users will complete a purchase. At 60%, the design has to do more persuasive work, testimonials, explanations, comparisons, and reassurance signals may help the user move toward a decision. At 90%, the user is already motivated, and the design should start removing friction so the action can happen quickly. Same screen, very different design problem.

Note: This is an oversimplification of the idea. Please be mindful of the intricate details of your product.

AI can also simulate outcomes using historical data and behavioral models before you commit to a direction. The value of those simulations depends heavily on how prompts are structured, the context they define, the hypothesis being tested, user motivation, and the edge cases you want stressed.

I can think of one such practical use: evaluating early designs through structured prompts, especially when you don’t have direct access to the user group you’re designing for. The prompt below is a starting point for evaluating a design from the perspective of neurodivergent users as well. Treat it as a template, adapt the user group, criteria, and output format to your product, and use it as a conversation starter with your team rather than a verdict.

Evaluate the [design file or weblink] for usability, accessibility, and content relevance from the perspective of neurodivergent users such as those with autism spectrum disorder, ADHD, learning disabilities, etc.
Please consider the following criteria:
Is the layout and navigation intuitive for neurodivergent users?
Is the language and content appropriate and engaging for neurodivergent users?
Are there any barriers (technical, cognitive, or sensory) that this group might face when using the site?
How well does the site meet the specific needs or goals of neurodivergent users?

Provide a SWOT analysis, probability score for successful use by neurodivergent users, and any recommendations for improvement.

Note: This is an oversimplification of the idea. Please be mindful of the intricate details of your product and make any appropriate changes.

That said, simulations do not replace experimentation. Because models are trained on historical data, they reflect past behavior more strongly than they predict future change. Imagine designing a voice interface for elderly users who struggle with touchscreens. A model trained on mobile interaction data might predict low engagement, not because the idea lacks value, but because the dataset reflects different user behavior. Simulations should always surface assumptions, not prevent innovation.

Be Cautious of Skewed Probabilistic Thinking Using AI

AI systems are built on historical data, more specifically, on the datasets they are trained on. That foundation shapes the outputs we receive. During the AI Summit in France, India’s Prime Minister Narendra Modi shared an example that illustrates this well. If you ask an AI model to generate an image of a person writing with the left hand, the output may still show a person writing with their right hand. The reason is statistical: most people are right-handed, and the training data reflects that. This may have improved over time, but the point remains relevant. I still occasionally see this behavior when generating images with similar models.

What you receive is not truth. It is the most statistically likely outcome given the data available. Always ask whether past data meaningfully predicts future behavior. If additional context can improve the prediction, include it. Without context, the output is just one of many possible answers dressed up as the only one.

(Large preview)

Confidence scores deserve the same scrutiny. Overtrusting a high-confidence output leads to the Air Canada situation. Dismissing a low-confidence one can cause teams to miss a real signal buried in noisy data. A prediction with 90% confidence is not necessarily correct, and a 40% signal is not necessarily useless. Designers must still weigh the possibilities, consider the case in front of them, and bring judgment to what the AI recommends.

Transparency is how you make that possible. As AI systems increasingly shape decisions, people need visibility into how outputs are generated, the sources, the reasoning, and the summaries behind a recommendation. Black-box systems breed distrust. Systems that reveal their reasoning let users evaluate outputs for themselves. That transparency is good design and ethical practice. It respects the trust people place in these tools.

Thinking in probabilities often means resisting the temptation of quick answers. AI can accelerate research and surface patterns faster than ever before, but those outputs are starting points, not final decisions.

Practice Probabilistic Design with AI

Design shapes how a product is ultimately experienced — the decisions designers make determine whether the experience feels adequate, intuitive, or exceptional. And design is inherently full of assumptions and bets. Even the most rigorous research can yield multiple valid solutions to the same problem, each carrying a different probability of success.

Thinking probabilistically means recognizing that design decisions rarely produce binary outcomes. They lead to a range of possible results, and the role of the designer is to navigate those possibilities and identify the path most likely to create value. This mindset also builds adaptability: user needs evolve, strategies change, and sometimes ideas fail. Teams that lean on data signals, experimentation, and learning loops move faster toward the most effective solution.

Before the practical principles, one fundamental idea:

Design decisions should be optimized for likelihood, not certainty.
“

Design for Likelihood, Not Certainty

Every design decision is a bet, not a guarantee. Even when decisions are informed by research and data, they are still based on smaller samples and assumptions about how users will behave at scale. A well-researched idea can still fail in the real world.

The Air Canada chatbot from the introduction is a design lesson as much as a legal one. The bot was doing what language models do, predicting plausible text. The interface, however, communicated that prediction with complete confidence, no caveats, no “here’s what our policy usually says,” no obvious path to a human. The user read confidence as commitment, and legally, so did the tribunal.

This is what happens when probabilistic systems are wrapped in deterministic interfaces. The interface transforms likelihood into certainty, and that is where the risk emerges.

Designing for likelihood means letting the interface continue to have uncertainty, visible fallbacks to human support, and clear labeling when content is AI-produced, preventing unforeseen issues.

Designers should avoid binary thinking — a great idea does not mean guaranteed success, and a familiar idea is not guaranteed to fail. Examine variations, confidence levels, and edge cases instead. AI can certainly help here, acting as a portfolio-thinking engine that surfaces different interpretations, highlights risks, and generates structured recommendations. The goal is not to optimize for certainty, but for value: it should always be value-driven.

Think of the moment in Avengers: Infinity War when Doctor Strange tells Tony Stark that out of millions of possible futures, there is only one where they win. AI cannot tell you the future, but it can help you explore the possible paths. Instead of asking whether an idea will succeed, ask AI to estimate the likelihood and get a score, and use those signals to guide decisions.

Use Data as a Compass, Not a Map

Even an actual probability is not a final answer. Imagine an AI model predicts an 80% likelihood that users prefer a minimal checkout experience. That does not mean the solution is simply “build a minimal checkout.” Data should function as a compass, not a map.

Why did the model produce that prediction?
What data influenced it?
What assumptions is it leaning on?
What user behavior is it actually detecting?

These questions help designers validate predictions through usability testing and additional research. AI excels at identifying patterns, but it rarely explains why those patterns exist. Understanding motivation is still a human-centered research task.

The clearest cautionary tale here is Amazon’s experimental AI recruitment tool, which the company reportedly scrapped after discovering that the model had learned to downgrade resumes from women. The training data, roughly a decade of historical hiring decisions, was skewed toward male candidates, and the model inherited that skew. It began penalizing resumes that included the word “women’s,” as in “women’s chess club captain,” and favoring language more commonly found on men’s resumes. The system was not intentionally biased — the data was. Amazon reportedly tried to adjust it and eventually shut the project down because they could not guarantee it would not surface other discriminatory patterns.

Examples like this are why interpreting AI output critically matters. Designers need to understand the data behind a prediction and evaluate the reliability of the models they depend on. A recommendation is only as good as the data it was trained on, and the only way to know what that data is hiding is to ask.

Experiment as a Learning System

Experimentation is usually framed as a way to validate a design decision. Want to lift the click-through rate of a CTA? Run an A/B test. Probabilistic thinking reframes this. Experiments should not only confirm solutions but also reduce uncertainty.

Traditional approach: Testing features to confirm success.
Probabilistic approach: Testing assumptions to reduce uncertainty.

Traditional A/B testing is expensive. It costs engineering time, traffic allocation, and user exposure, especially when a losing variant runs against a significant chunk of your audience. AI simulations can help filter weaker ideas before they reach production by making experimentation more efficient. User needs shift constantly, and the most effective teams iterate fast.

AI can help evaluate assumptions early by modeling potential outcomes based on historical and behavioral data. These simulations act as a hypothesis filter, pointing to the directions worth investing engineering effort in. This also supports personalization — different users may respond better to different experiences. Version A may resonate with high-intent users while version B works better for exploratory ones. Multiple experiences living side by side are not a flaw; they can be an intentional strategy.

AI amplifies probabilistic thinking by surfacing scenarios, assigning likelihood scores, and enabling personalization at scale. Experimentation becomes a continuous feedback loop:

Predict → Test → Learn → Adjust → Repeat!

A few steps to make it work:

Shift the framing
- So instead of saying: Will this feature succeed?
- Ask: What assumptions are we testing?
- Use this template to define the hypothesis:
  We believe [behavioral assumption] will impact [metric] because [reason]. We’ll know we are right when [evidence].
  Example: We believe simplifying the onboarding flow from 5 steps to 3 will increase completion rate because users experience decision fatigue when too many choices are presented. We’ll know we’re right when we see at least a 15% increase in step-to-step conversion with no drop in activation rate.
AI simulations
- Use AI to predict some of the assumptions.
- Later, use the learning to identify the top candidates to test the hypothesis.
Embrace multi-versions
- It is absolutely fine to have two live versions.
Fail fast
- Reward learning vs success.
- Normalize smaller experimentations instead of a sweep of large changes. So instead of taking on a risky bet, pick up a few probabilities and test them.
Visualize probability
- Create a probability table with probabilities of each variant and its prediction of success to keep track of all the changes.

One of the hardest things for designers is making uncertainty understandable and actionable. When uncertainty is hidden, users treat AI outputs as facts. When it’s communicated clearly, trust increases.

Ranges, estimates, and confidence indicators go a long way. A delivery window of “Friday to Monday” tells the truth about variability without misleading anyone, whereas a specific timestamp that slips erodes trust every time. A face recognition feature that says “this looks like Pratik, is that right?” sets more honest expectations than one that just labels the photo with a name.

(Large preview)

Communicating uncertainty does not weaken trust — it strengthens it. The goal is not to eliminate uncertainty but to design for it intelligently.

Different users respond to uncertainty differently, and your design should account for that:

User type	Risk	Design goal
Overtrusting users	They act too quickly and trust AI results easily./	Show uncertainty more prominently.
Distrustful users	They ignore AI entirely.	Show historical accuracy or confidence levels.
Skeptical/balanced users	Uses AI as a guide, not as a rule.	Reinforce AI assistance and let them decide the sort of framing.

Keep Humans In the Loop

AI should augment human judgment, and certainly not replace it. The most trustworthy systems are designed with clear moments where people can review, challenge, correct, or override machine suggestions. Human-in-the-loop (HITL) is not a safety net — it is a refinement engine. Every override, correction, or rejection becomes high-quality feedback that improves the model over time.

Control is a prerequisite for adoption. Users are more willing to rely on AI when they understand how a suggestion was generated, can evaluate its implications, and can easily intervene. Well-designed products make this explicit: who is acting, what happens if the suggestion is wrong, and where the user can step in.

These interactions are also critical for system improvement. Every accept, reject, or edit is a strong signal, and compared to passive analytics, this kind of feedback produces far more meaningful training data. It closes the loop between real-world usage and model performance.

What Does HITL Look Like in Practice?

GitHub Copilot is a good everyday example. It offers inline code suggestions that developers can accept with a tab, edit, or ignore entirely. The system never commits code on the user’s behalf. Authorship stays with the humans. Every data point becomes implicit feedback about which suggestions were useful. Gmail’s Smart Compose works similarly, presenting predicted text as optional, keeping tone and intent in the user’s hands.

In higher-stakes contexts, HITL becomes more explicit. Risk and fraud systems typically use probability scores to route decisions: low-risk: proceed automatically; medium-risk: trigger additional verification; and high-risk: escalate to a human reviewer. This balances speed with judgment without removing oversight.

In safety-critical domains like healthcare, human oversight is non-negotiable. AI may flag anomalies or suggest a diagnosis, but the clinician retains final authority. Tools that explain the details help the practitioner understand why a recommendation was made, reinforcing confidence without removing accountability.

Designing for Human Judgment

From a UX perspective, HITL is about matching the interaction pattern to the level of risk. Simple accept/reject affordances work well for low-risk suggestions that improve speed without real consequences. As the stakes climb, impacting data, money, or people, preview and approval steps become essential. Explanations help users calibrate trust rather than blindly accept outputs.

What happens behind the scenes matters just as much. The system should capture user decisions with context, feed them into learning workflows, and log overrides for auditability. Over time, teams can track signals like override rate, confidence accuracy, time-to-approval, and perceived trust. A high override rate is not a user failure. It is a signal that the design or the model needs attention.

The Risk of Getting It Wrong

Poorly implemented HITL systems can fail in subtle ways. Human review can devolve into a rubber stamp. Workflows can slow down so much that users route around the safeguards. Feedback can skew toward a narrow subset of users. These risks are real, but they are design problems, not reasons to remove HITL.

The goal is not to maximize human involvement. It is to focus it where uncertainty, impact, or ethics demand it. Keeping HITL is less about control and more about clarity: clarity about who decides, when uncertainty matters, and how responsibility is shared between people and machines.

Optimize for Resilience, Not Just Conversion

Good design adapts as the landscape shifts. Product design, especially in AI-powered systems, can no longer afford to optimize only for short-term conversion metrics. User intent is fluid as well as ever-changing, environments change rapidly, and probabilistic systems continuously evolve too. What works today can quietly break tomorrow. Designing for resilience means building products that stay reliable, trustworthy, and useful even as assumptions, data, and user behaviors change.

Resilient design shifts the question from:

How do we maximize this metric right now?! → How does this system behave over time, under stress, and in uncertainty?

A resilient system is one that:

Adapts as new data and behaviors emerge.
Fails safely rather than catastrophically.
Remains transparent and explainable.
Avoids brittle, over-optimized interaction patterns.
Anticipates second-order and unintended effects.

Do not just consider last quarter’s numbers. Peek into the following quarters to identify the shift and make changes accordingly.

Build Systems That Adapt as Probabilities Change

Likelihoods shift constantly, AI models drift, contexts evolve, and user needs mature as well, so designing as if conditions are stable creates fragility in probabilistic environments. A resilient approach assumes volatility as the default.

Think about how recommendation systems tend to evolve. The early version of a content feed optimizes for engagement, and for a while, engagement goes up. Then users start to notice the feed feels narrow, repetitive, maybe even exhausting. Resilient systems rebalance, introducing novelty, diversifying signals, and pulling in long-term satisfaction measures alongside short-term clicks.

Designers should create interfaces that expect change, dynamic re-ranking, contextual explanations, and escape hatches from stale personalization loops, all of which help systems stay useful as probabilities shift.

Optimize for Long-term Outcomes, Not Just Short-term Wins

Short-term conversion gains often hide long-term costs. Speeding up onboarding can reduce comprehension. Maximizing notification CTR can erode trust. Optimizing engagement alone can produce unhealthy usage patterns. Fragile systems maximize numbers while ignoring second-order effects, the downstream consequences that show up weeks or months later.

Duolingo’s hearts system is a good example of designing against this. It introduces friction: if you make too many mistakes, you run out of hearts and have to wait or practice older material to earn more. On paper, that looks like a conversion killer: fewer lessons per session. In practice, the team has publicly discussed how it supports long-term motivation and retention, which is the metric that actually matters for a learning app. Short-term engagement dips, but long-term outcomes improve.

Meta has made a similar, if more reluctant, shift. The company publicly acknowledged that optimizing purely for “time spent” produced unintended emotional and societal effects, which led to a stated pivot toward “meaningful social interactions” as a guiding metric. Whether that shift fully landed is up for debate, but the acknowledgment itself is the point: optimizing for the wrong thing at scale has real downstream cost.

So, designers must routinely ask:

What behaviors are we unintentionally reinforcing?
Will this interaction still be healthy if repeated at scale?
Are we optimizing for the ecosystem’s wellbeing or just the next click?

Plan For Uncertainty the Way You Plan For Scale

Teams routinely plan for traffic spikes, but rarely for uncertainty spikes. Yet AI systems degrade, adversarial behaviors evolve, and external shocks can reshape user behavior overnight. Resilient design assumes variability and prepares for it.

This means designing for degrading confidence. What does your interface do when the AI isn’t sure? Does it quietly fail, or does it gracefully hand off? Does the experience still make sense if AI assistance goes away entirely? A good fallback strategy is as important as the happy path.

Some practical actions:

Design for degrading confidence.
Show fallback states, allow manual overrides, and visualize uncertainty where it matters.
Measure long-term user health.
Track satisfaction, retention quality, and unintended behavior, not just conversion.
Build adaptability in.
Use adjustable ranking rules, dynamic states, and continual experimentation across segments.
Model second-order effects early.
Every optimization casts a shadow; surface it before shipping.
Use a resilience checklist before launch.
How does the system behave under low AI confidence? What’s the safe fallback? What drifts do we anticipate?

Conclusion

If you take one thing from this article into your next design review, make it this:

Stop asking “Will this work?” and start asking “How likely is this to work, and what happens when it doesn’t?”

That single reframe changes how you write hypotheses, interpret AI output, scope experiments, and design for the moments when the system is wrong. Starting this week, name the assumption behind every AI recommendation you accept, find one place in your product where a probabilistic output is presented as a certainty, fix the framing, and design the fallback before the happy path.

The shift from deterministic to probabilistic design is less about new tools and more about a new posture. AI has not introduced uncertainty into our world. It has simply made the uncertainty that was always there impossible to ignore. AI can estimate, simulate, and recommend, but it cannot decide what matters, which users are being overlooked, or which unconventional idea is worth defending against a model trained on yesterday’s data. Those remain human responsibilities. Think in ranges, not points. Test assumptions, not features. Build for adaptation, not perfection. In a world where prediction is cheap, and judgment is rare, the most valuable thing a designer can do is keep asking, What else might be true?

The 8 Most Brutal Business Quotes Ever Said And The Stories Behind Them

noreply@blogger.com (H) — Mon, 27 Jul 2026 07:14:56 +0000

Anyone can find a motivational quote.

What you cannot find easily is the story behind it. The moment it was said. What was happening. Why it actually meant something.

This edition is different. Every quote below comes with the context that makes it hit harder than any poster on a wall ever could.

"I knew that if I failed I would not regret that, but I knew the one thing I might regret is not trying."

JEFF BEZOS, 1994

Jeff Bezos said this in 1994. He was 30 years old, earning a six figure salary at a Wall Street hedge fund, and had just told his boss he wanted to quit to sell books on the internet.

His boss asked him to take 48 hours before deciding. Bezos went for a long walk. He came back and quit anyway. He drove cross country to Seattle with his wife, writing the Amazon business plan on the way.

At the time, only 16 million people had ever used the internet. Nobody was buying anything online. Every single person who heard his plan told him it would not work.

He has since said the regret minimisation framework, asking yourself what you would regret more at 80, not trying or trying and failing, is the single most useful thinking tool he has ever used.

The rest, as they say, is a $2 trillion company.

QUOTES YOU HAVE NEVER SEEN ON A POSTER

"Everybody has a plan until they get punched in the mouth."

MIKE TYSON

This was not about boxing. Tyson said this before a fight when a reporter asked how he felt about his opponent having a detailed game plan. It became the most quoted business line nobody expected to come from a boxer. Every founder who has ever had a beautiful pitch deck destroyed in the first investor meeting knows exactly what this feels like. The plan is not the strategy. The ability to adapt after the punch is.

"The most dangerous poison is the feeling of achievement. The antidote is to every evening think what can be done better tomorrow."

INGVAR KAMPRAD, FOUNDER OF IKEA

Kamprad built IKEA from a small mail order business in rural Sweden into the largest furniture retailer on earth. He was also famously frugal to the point of obsession, flying economy class until his 70s and driving a decades old Volvo. The quote above is why. He genuinely believed that the moment you feel satisfied is the moment you start declining. He ran IKEA with that paranoia until the day he died at 91.

"Your most unhappy customers are your greatest source of learning."

BILL GATES

Gates said this at a time when Microsoft was being publicly destroyed in the press for buggy software and poor customer service. Instead of defending the product, he built entire internal systems around studying complaints. The feedback loops he created became one of Microsoft's core operating principles. Most founders hide from negative feedback. Gates built a company around chasing it.

"I never took a day off in my 20s. Not one."

BILL GATES

This one is uncomfortable because it contradicts every work life balance conversation happening right now. Gates has since said he does not recommend this. But he also built Microsoft in those years. The honest version of this quote is not a prescription. It is a description of what it actually took, at that specific moment in history, to build something from zero to dominant. Draw your own conclusions.

QUOTES THAT GOT LAUGHED AT, THEN PROVED EVERYONE WRONG

"There is no reason anyone would want a computer in their home."

KEN OLSEN, FOUNDER OF DIGITAL EQUIPMENT CORPORATION · 1977

This was not mocked at the time. Everyone agreed with him. He was the most respected computer executive in America.

Three years later, Apple launched the Apple II. The rest of the industry followed. Olsen's company went from $6 billion to bankruptcy. The quote lives on as the most expensive wrong prediction in tech history.

2. "Nobody is going to pay to watch other people play video games."

EVERY MEDIA EXECUTIVE · 2008

Twitch's founders were laughed out of pitch meetings. The concept of live streaming gaming was considered absurd. One investor called it "the dumbest idea I have heard this year."

Amazon acquired Twitch in 2014 for $970 million. Live streaming gaming is now a $4.2 billion industry. The investors who passed have not commented publicly.

3. "There is no chance the iPhone is going to get any significant market share."

STEVE BALLMER, MICROSOFT CEO · 2007

He said this on live television. He laughed while saying it. He pointed out that at $499 the iPhone was too expensive to get traction. He was certain.

The iPhone generated $200 billion in revenue in 2023 alone. It is the single most profitable consumer product in history. Ballmer was Microsoft CEO for another six years after this interview.

The pattern across every quote above is the same one.

The people who said the thing everyone else thought sounded wrong were either completely right or completely wrong. There is no middle ground in bold thinking.

The people who nodded along and said nothing built nothing worth quoting.

Self Employed Insider covers the stories, decisions, and thinking behind the people building things worth remembering, every week, free.

Matching AI Modality To User Intent: Designing The Right Interface

noreply@blogger.com (H) — Sun, 26 Jul 2026 08:02:00 +0000

We’ve fallen into conversational tunnel vision, defaulting every AI capability into a chat-based interface simply because LLMs are trained on dialogue data. But great UX is about matching modality to users’ context, intent, and cognitive load, so the interface adapts to the user, not the other way around.

The design community has entered a period of conversational tunnel vision. Because Large Language Models (LLMs) are trained on dialogue, the industry has collectively decided that the chat bubble is the natural home for every AI capability. While the chat interface is a viable and powerful option for many tasks, it is one tool in an expansive toolkit. UX and Product teams must be intentional about the modalities we choose for how users provide their data and commands, and how the system presents its output.

Modality is the way a person uses their senses to interact with a system: seeing, hearing, touching, speaking, or typing.

To pick the best method, you need to think about what the user wants to do, where they are, and how much cognitive effort they are already expending. This guide offers a clear way to figure out the best approach for any product, using two tools to assist in the process: a Task Audit and an Input/Output Alignment Matrix.

Picture a traveler jogging through a loud airport terminal after a sudden gate change. They are dragging their roller bag and carrying a coffee in the other hand. They need to open their airline app to ask the AI assistant where to go. The tool immediately fails the input modality test. It forces the traveler to stop walking, balance their coffee, and type a long booking reference number into a tiny chat box. When they finally hit send, the system fails the output modality test. Instead of flashing a large, high-contrast gate number, the AI returns a dense paragraph explaining the atmospheric weather patterns causing the delay. The actual gate number sits buried at the very bottom.

While they might make the flight just fine, the user won’t forget the moment of anxiety they felt while using the AI tool — an experience that could have served as a way to reinforce a commitment to UX has instead validated the common conception that companies don’t care about or understand customers using their products. In this scenario, the airline built a smart tool, but the interface failed the user. The input required physical dexterity, which the traveler lacked at the time of need. The output demanded a level of reading focus they could not spare. This article will cover how we can avoid this scenario in our AI-powered tools. In order to be successful, we must evaluate the physical and cognitive load of our users to match both the input and output modality to their immediate intent.

Let’s first discuss the limitations of a chat-based interface.

Myth of the Do-It-All Chatbot

The allure of the chatbot is easy to understand from a product development standpoint. It is a blank slate. It suggests that the system can handle anything the user provides. However, a text-heavy interface often causes a high adaptation load. This load increases cognitive demands on users. Over time, this cognitive burden turns into a psychological tax a person pays when changing natural thought processes to accommodate a machine.

When an interface relies solely on conversation, it imposes a dual burden: a linguistic challenge for input and a cognitive challenge for output. We’ll examine both separately below.

Input: Why a Text Box is a Linguistic Barrier

A blank chat box creates a major problem for users who need to discover what a tool can actually do. In a standard graphical interface, menus and buttons provide clear visual cues that signal every available option. A chat box often leads to choice paralysis because users are forced to guess what the AI is capable of. They have to remember the exact phrasing or technical terms required to get the result they want.

Consider a data analyst who wants to find a specific trend in a spreadsheet. In a traditional tool, they might click a filter or sort button. In a chat interface, they must suddenly become a writer and describe that complex logic in a complete sentence. Another example: a manager trying to reorganize a team schedule. Dragging and dropping blocks on a calendar is intuitive. Describing those same scheduling shifts in a text prompt adds a layer of work that makes the task feel more difficult than it should be.

Designing for input means recognizing that composing a prompt is a creative act. It requires a person to translate a vague thought into a specific command. For many professionals, this creates a linguistic barrier. A designer might know exactly how they want an image to look but struggle to describe the lighting or texture in a text prompt. In that case, a slider or a color picker is a much better input method than a text box.

Having addressed the linguistic barrier of constructing input prompts, we must now consider the other half of the conversational burden. This is the cognitive cost the AI imposes when it responds in dense blocks of text.

Output: The Cognitive Cost of Reading Long Text

When an AI responds in long blocks of text, it transfers the interpretive work to you, the user. Text is a serial medium: your brain has to read one word after the next to extract meaning. That takes time. Sequential reading is necessary in many scenarios. Complex legal analysis or reviewing nuanced medical histories requires reading full paragraphs. Teams create friction when they default to text for data that visual formats communicate faster. Visual methods allow parallel processing. You can view a chart and spot a pattern in under a second.

Imagine asking an AI for a project status update. Instead of a color-coded dashboard, you receive three paragraphs listing every task completed that week. Now you must read the entire response and mentally summarize it to find the one piece of information you needed. The quick visual check has been replaced by a reading assignment.

The cognitive tax of this work compounds with professional stakes. A doctor asking for a patient’s vital signs needs a clear numerical display, not a narrative describing the readings. A stock trader looking for a price spike needs a line graph immediately, not a written description of price movement over the past hour. In both cases, a text response forces the professional through a slow, error-prone extraction process when speed and accuracy are most important.

Figure 1: Redesigning for psychological fatigue. The linear text loop (left) forces exhausting sequential verification, causing anxiety. The graphical selection grid (right) permits instant, low-effort visual confirmation (glance verification).

A Taxonomy of Input and Output Modalities

Before selecting a modality, practitioners need a shared vocabulary for what the options actually are. The table below maps common input and output modalities to the contexts where each performs best. This is not a ranking. Each modality has a role; the question is always which role it is playing in a given workflow.

Designing for modality inherently requires a strong focus on accessibility. While visual dashboards provide rapid insight for many people, designers need to provide screen-reader-optimized audio alternatives for users with visual disabilities. Modality choices should multiply pathways to information.

Input Modalities

Modality	Best For	Example Contexts	Cognitive & Physical Rationale
Button / Tap	Single-step, binary actions	Launching a feature; confirming an alert	Eliminates recall overhead by utilizing recognition; maximizes execution speed during time-sensitive tasks.
Voice	Hands-busy or eyes-busy contexts	Field technician query; driving navigation	Offloads physical interaction to speech, though bounded by ambient noise and social privacy norms.
Natural Language Chat	Ambiguous or exploratory queries	Researching options; asking follow-up questions	Offers users freedom in what they can say; however, the user must figure out how to phrase their request clearly.
Form / Wizard	Structured, multi-field data entry	Filling out a contract; configuring a report	Keeps users from missing information by breaking down a complicated task into clear, step-by-step visual sections.
GUI (Filters, Sliders, Drag-and-drop)	Complex parameter setting or spatial tasks	Scheduling; data filtering; image editing	Prevents mistakes and ensures users don't miss information by dividing complicated tasks into clear, step-by-step visual parts.
Multi-modal (Image + Text)	Visual input paired with description	Uploading a design mockup with annotation	Reduces the effort of explaining things because users can reference an object instead of having to describe it only with words.
Gesture	Hands-free spatial interaction	Waving a hand to acknowledge an alert in a sterile operating room	Allows physical interaction without touching a surface. This keeps users safe and clean in contaminated environments and allows for quick input or acknowledgement.

Output Modalities

Modality	Best For	Example Contexts	Cognitive & Physical Rationale
Push Notification / Alert	Time-sensitive, ambient awareness	Price spike alert; task completion notice	Provides a quick update that the user can process at a glance. It delivers information without demanding a full break in concentration from their primary task.
Audio Summary	Hands-busy or eyes-busy contexts	Status updates while walking; conversational voice agents providing real-time navigation	Delivers information directly to the user’s ear. Removes the need to look at a screen, keeping the user safe and aware of their physical surroundings while moving or working.
Short Text Summary	Focused queries needing brief answers	Definition lookup; single-metric status	Gives a fast answer to a direct question. Users can read a short sentence quickly without experiencing the fatigue of scanning paragraphs of text.
Visual Dashboard	High-density, comparative analysis	Project status; resource allocation	Enables visual trend and outlier detection. Avoids the mental effort of reading data line-by-line and cross-referencing in real time.
Interactive Canvas	Generative or iterative creative tasks	Design iteration; layout adjustment	Allows users to manipulate the output instead of asking an AI to move it via text instructions. Reflects a natural way to interact with the output.
Inline Confirmation	Guided task flows needing feedback	Step-by-step configuration wizard with in-line validation	Provides visual proof that the system recorded a choice correctly. Reduces users’ anxiety about wondering if an error occurred.

Table 1: Input and Output Modality Taxonomy. Use this as a reference during the Task Audit to identify candidate modalities before narrowing to a recommendation.

The following FigureFigure 2 illustrates the cognitive spectrum, mapping how mental effort scales across various interaction methods. This spectrum is a critical tool for designers to visualize the shift from low-effort, ambient interactions to high-effort, focused experiences. By understanding where a specific task sits on this spectrum, teams can identify whether a user needs a “glanceable” output that minimizes mental processing or a high-density format that supports deep, analytical thinking.

Figure 2: The Cognitive Spectrum of Modality. Both input (top) and output (bottom) move from low-effort, ambient interactions to high-effort, focused, and multi-modal experiences, illustrating why the context of use must dictate the design choice.

With this taxonomy established, the next step is to apply a rigorous method to select the optimal input and output combination. Practitioners must ground this selection process in the user’s real-world environment and context.

Task Audit: A Framework for Modality Selection

To choose the right interaction method, practitioners should complete a Task Audit before interface design begins. A formal Task Audit is the framework that moves teams from assumptions about user behavior to evidence. This process gathers data about the physical, social, and cognitive context in which the work actually happens, which then drives all input and output modality decisions.

Use these four areas of focus to anchor the audit:

Input Constraints: This addresses whether the user can physically interact with the system using their hands, such as typing or tapping. It often dictates the necessity of hands-free interaction methods like voice input when the user’s hands are occupied by tools or gear.
- Can the user use their hands to type or tap? A mechanic working under a vehicle might need to ask a question using only voice because their hands are occupied and covered in grease.
Output Constraints: This defines whether a user can safely and practically view information on a screen. It concerns situations where a user’s eyes must remain focused on their environment, making audio or glanceable visual cues the appropriate display method.
- Can the user safely look at a screen to read information? A delivery driver’s navigation system should provide audio directions because reading a detailed map while driving through an intersection is dangerous.
Social Constraints: This considers the environment’s tolerance for audible interaction, either speaking or listening to audio output. It helps determine if a quiet space requires silent alerts or if a loud environment demands a non-audio output method.
- Is the environment appropriate for speaking aloud or listening to audio? An office worker in a quiet, open-plan space would prefer a silent text notification over a spoken voice response.
Cognitive Load: This measures the amount of mental effort the user must already dedicate to their primary task. Teams must design the interface output to either minimize mental processing, such as with a quick visual indicator, or support deep thinking with a detailed summary.
- How much mental effort does the task already require? A surgeon needs a quick visual red indicator during a procedure, while a lawyer researching case strategy needs a detailed text summary to absorb at their own pace.

The audit answers two questions for every feature:

What modality can the user physically use to provide input here?
What modality can the user realistically process as output here?

Here is how to gather the evidence to inform your task audit. Use one or more of these common UX research-related methods:

1. Contextual Inquiry and Observation

This is the most direct way to capture how people work in their natural setting, and it provides the richest data for identifying physical constraints on both input and output. Observation is necessary because users often perform hidden work: small steps or workarounds they forget to mention in an interview, or environmental details they do not think to describe because they have adapted to them.

The Approach: Go to the user’s actual workspace, whether a field site, warehouse, or office floor. Ask them to perform the task you are studying and observe closely.

What to Look For: This method is most revealing for Input Constraints and Output Constraints.

Input example
A technician diagnosing equipment who cannot put down their tools rules out typing and points directly to voice input.
Output example
A supervisor in a meeting who looks up and down repeatedly from a screen signals a need for glanceable, low-density output rather than a scrolling text summary.

2. Focused Interviews

Interviews surface the mental models and decision points that observation cannot capture. They are most valuable for understanding Cognitive Load.

The Approach: Conduct one-on-one sessions with end-users and the stakeholders who manage the outcome. Use a structured protocol focused on a specific task. Ask for stories about past successes and failures rather than general opinions.

What to Look For:

The “Why” Behind High Cognitive Load
Ask users to describe the hardest part of a task. A lawyer may explain that the volume of detail is not the challenge; synthesis for ethical or strategic judgment is. This confirms a need for detailed text output the user can read and absorb at their own pace, not a summary dashboard.
Process Ambiguity
Uncover situations that are unclear or error-prone, which identifies where AI capabilities provide the most leverage and what output format will reduce rather than increase ambiguity.

3. Collaborative Workshops

Workshops are essential for defining task boundaries and establishing required fidelity levels. Product managers and stakeholders bring foundational knowledge of system requirements; researchers apply audit criteria.

The Approach: Use workshops to build a shared Task Inventory. Bring designers, engineers, product managers, and business analysts together to map every step of the process. Product managers and business analysts ensure factual accuracy; the research team applies audit criteria to each step.

What to Look For:

Social Constraints
Confirm where tasks are performed. A workflow that takes place on a loud manufacturing floor versus a shared quiet library demands very different output modalities.
Ambiguity and Speed Tests
For every task in the inventory, apply two tests. First: Does this step require human ethical judgment? If yes, the AI output must support that judgment, not replace it. Second: Does this step require instantaneous execution? If yes, the interface must support fast input with minimal cognitive overhead.

Once you gather field evidence through these research channels, map your findings directly against the Modality Taxonomy. Each concrete physical or social constraint you document systematically eliminates mismatched interfaces. This process strips away design guesswork, narrowing your architectural choices down to the specific input and output combinations that survive the reality of the user’s environment.

When you ground input and output modality decisions in field evidence rather than interface convention, the resulting design reduces adaptation load for the user and grounds your modality choices in evidence. When you base decisions on field data, you move past interface convention and build a powerful case for the resources needed to create the right experience for your users.

Once the audit is complete, the final step is utilizing the Input/Output Alignment Matrix to formalize the connection between user intent and the optimal modality combination.

Input/Output Alignment Matrix

With Task Audit findings in hand, you can use an Input/Output Alignment Matrix to map user intent to specific modality combinations. This matrix is organized by what the user is trying to accomplish in a given moment. This distinction versus focusing on what your AI is capable of doing matters. If intent changes across a single workday for the same user, the interface should respond to those shifts.

Choosing the wrong modality for the user’s context can lead to user frustration. Users might feel mentally drained if a lot of information is delivered through a format that is hard to process, like getting a massive status update only in text. They may also start worrying if an action was actually completed correctly when a precise command is buried within a long chat exchange. Finally, the system can force users into finding clumsy workarounds, making them adapt to the machine’s method instead of working in their natural, most effective way.

User Intent	Optimal Input Modality	Optimal Output Modality	Environmental Fit
Quick Status Check	Voice or Single-tap Button	Audio or Push Notification	Hands-busy, Eyes-busy (e.g., Technician on ladder)
Specific Detail Query	Natural Language Chat	Short Text Summary	Focused, low-density data need
Complex Analysis	GUI (Filters, Sliders)	Visual Dashboard (Charts, Tables)	Desk-based, high-resolution screen
Creative Generation	Multi-modal (Image + Text)	Interactive Canvas	Design or drafting environment
Monitoring / Alert	Passive (background system)	Push Notification or Audio Alert	Any environment; task is ambient awareness
Guided Task Completion	Structured Form or Step-by-step Wizard	Inline Confirmation + Progress Indicator	Focused workflow; user needs verification feedback

Table 2: Input/Output Alignment Matrix. Map user intent to modality combinations using Task Audit evidence. The two added rows (Monitoring/Alert and Guided Task Completion) cover common enterprise and mobile scenarios not captured in simpler frameworks.

When teams coordinate these factors, they can move past the automatic default of adding a chatbot. Visual layouts enable rapid scanning. Structured inputs remove the burden of constructing perfect sentences. Audio outputs serve users whose hands and eyes are otherwise occupied.

The right modality combination respects the user’s physical and cognitive state at the moment of interaction.

A real-world scenario where environmental constraints dictated a shift in design strategy best demonstrates the practical application of this matrix and the broader audit framework.

Case Study: Adaptive Modality for Field Technicians

The Problem: Cognitive Overload in High-Risk Environments

Field technicians servicing high-voltage electrical grids often face a dangerous misalignment of interface modality. Traditionally, these technicians had to rely on ruggedized tablets to access technical manuals and log status updates. However, the physical constraints of the job — wearing heavy protective gloves and working in bucket trucks at significant heights — made interacting with a standard touch interface nearly impossible while on a job site. Additionally, attempting to read complex, text-heavy diagnostic reports on a screen while maintaining situational awareness created a high cognitive load that increased the risk of safety errors.

Research Methods: Capturing the Reality of the Field

To address this, researchers conducted a Task Audit utilizing three specific methods from this article. First, Contextual Inquiry and Observation revealed that technicians often worked in “hands-busy, eyes-busy” states where any manual input was a significant barrier. Researchers observed technicians wearing mandatory thick protective gloves while in the bucket truck, which made precise screen taps nearly impossible and often triggered the wrong commands.

High-altitude environments also introduced severe screen glare from direct sunlight, washing out the display and making text difficult to read even at full brightness. Furthermore, technicians faced the physical safety risk of trying to manipulate and secure a heavy, ruggedized tablet while balanced in awkward positions, creating a distraction that could lead to dangerous slips or equipment contact. These factors, combined with the need to constantly monitor live wires and the surrounding environment, meant technicians could not safely dedicate their eyes or hands to a standard tablet interface, confirming the severity of the eyes-busy and hands-busy constraints.

Second, Focused Interviews with veteran technicians validated the findings from the field. They confirmed that the operational challenges, including the thick gloves, screen glare, and safety risks, were not unique to one location but were commonly experienced across multiple sites, including high-altitude transmission lines and sprawling power substations. This broad confirmation solidified the need for a non-touch, voice-first solution. The interviews also surfaced a critical cognitive constraint: the need for glance verification of vital signs, such as voltage readings and temperature trends, rather than being forced to read a long narrative description of system health. Technicians stressed that their primary need was immediate, unambiguous verification (is this safe? or where is the fault?), not a lengthy diagnostic report, indicating that a text-heavy response was dangerous to their workflow.

These methods confirmed that the environment required a departure from the traditional chat or form-based AI capability interface.

The resulting solution implemented an adaptive modality handoff designed to mitigate the physical and cognitive barriers researchers identified during the research. While active on a job site, technicians utilize voice input to query the system. This method allows them to remain productive while wearing thick protective gloves that would otherwise prevent precise interaction with a touchscreen.

The AI responds with a short audio summary of immediate diagnostic data. This audio feedback bypasses the challenge of screen glare in high-altitude environments and allows the technician to maintain situational awareness of the high-voltage grid without the safety risk of looking away from dangerous equipment. By providing immediate answers to fault locations through audio, the system meets the technician’s need for glance verification through a hands-free and eyes-free channel.

Once technicians return to a truck and secure safety gear, a system automatically hands off workflows to a 15-inch visual dashboard mounted inside a vehicle. A rugged 10-inch field tablet lacks adequate screen real estate for complex schematics. A larger vehicle display allows for parallel processing of historical trend data and wide electrical grid maps. This case study reflects an actual field audit conducted for a national utility provider. Implementing this adaptive approach reduced diagnostic time by twenty percent and increased daily tool adoption among field crews.

Figure 3: Cross-modality handoff diagram for field technicians. Our solution to deliver AI capability using multiple modalities depending on context was the result of auditing user tasks and led to greater adoption of the tool.

Designing for the Environment

An AI capability is only as usable as the interface that delivers it. Researchers and designers must resist the pull toward the path of least resistance. Building a chatbot is fast and familiar, something we’ve been doing for decades now. Building an interface that feels like a natural extension of how someone already works is harder, and it is the work that matters.

Start by leaving the screen. The Task Audit requires presence in the places where work actually happens: the field site, the warehouse floor, the operating room. The physical and social realities of those spaces are not edge cases. They are the design brief.

The future of AI interface design is a diverse ecosystem: visual, vocal, haptic, and ambient, calibrated to user intent and environmental context. The chat window is one tool in that ecosystem. It is the right tool for specific jobs, and often the wrong tool for the jobs we reflexively assign to it.

In order for us to create the greatest likelihood of acceptance and use of the AI capability we offer users, we must fit the modality to the person and the place.

Where to Start

To get started immediately, run a lightweight version of the Task Audit before your next design sprint. Spend two hours observing the workflow in its actual environment. Conduct three to five interviews with the people who perform the task. Bring a PM or analyst into a 90-minute workshop to build a task inventory and apply the four audit questions. You will not have complete data, but you will have enough to make a defensible modality recommendation backed by evidence rather than convention.

I created a Modality Task Audit Template to help guide teams with moving forward. You can download this worksheet and take it directly to your next field observation. It allows design and product teams to document specific physical barriers before writing a single line of code.

Download: Modality Task Audit Field Template (PDF)

Inside this Template:

Step 1: Physical Reality Check.
An observation checklist to log hand availability, eye focus requirements, and ambient noise levels in a specific workspace.
Step 2: Cognitive Baseline.
A scoring grid to rate required reading density and verification anxiety for a given workflow.
Step 3: The Handoff Map.
A blank flow diagram to chart where a user starts a task (for example, using voice on a mobile phone in a warehouse) and where they finish it (for example, reviewing a visual dashboard on an office monitor).

We focus heavily on training smarter AI models. We owe equal attention to human interfaces. A brilliant underlying model packaged in a lazy text interface fails. When you observe actual work environments and align interaction modalities to them, you remove adaptation friction.

Modality Task Audit Field Template

Use this worksheet during field observations. It allows design teams to document specific physical barriers before writing code.

Part 1: Physical Reality Check

Observe users as they perform a primary task in actual workspaces. Check all applicable conditions.

State of Hands

Hands are free for typing.
User holds a clipboard or a smartphone.
User holds tools, drives a vehicle, or wears thick gloves.

Visual Focus Requirements

User focuses entirely on a screen.
User alternates glances between a screen and physical surroundings.
User watches live machinery or navigates crowded spaces.

Ambient Noise Level

Quiet environment (office).
Moderate noise (busy cafe).
Loud environment (construction site, loud retail floor).

Part 2: Cognitive Baseline

Rate the mental effort required to complete a specific workflow.

Metric	Low	Medium	High
Required Reading Density	Single numbers, binary states	Short summaries, simple instructions	Legal contracts, complex diagnostic reports
Verification Anxiety	Reversible actions, low stakes	Standard business operations	Irreversible actions, safety risks, financial transactions

Part 3: Handoff Map #

Chart user journeys across different environments. Document required input and output at each stage.

Stage 1: Initial Action

Location: ________________________
Input Method: ________________________
Output Method: ________________________

Stage 2: Context Transition

Trigger for environment change (example: user returns to a desk): ________________________

Stage 3: Completion Action

Location: ________________________
Input Method: ________________________
Output Method: ________________________

Weaponizing And Defending The React Flight Protocol: Deserialization Sinks In RSCs

noreply@blogger.com (H) — Sat, 25 Jul 2026 07:40:00 +0000

While React Server Components rely on the custom Flight protocol to stream interactive UIs, this same mechanism introduces powerful deserialization sinks that attackers can exploit. Durgesh Pawar breaks down the mechanics behind the CVSS 10.0 “React2Shell” vulnerability to show how protocol manipulation can lead to remote code execution. It also covers a practical, ranked set of defenses, from strict schema validation to CSRF hardening, for securing React applications against these structural risks.

React Server Components don’t send HTML to your browser. They don’t send JSON either. When a server component renders, what actually travels over the wire is a custom streaming protocol called Flight. It’s a line-delimited format with its own type system, its own reference resolution, and its own rules for reconstructing executable behavior on the client.

Most React developers have never opened the Network tab and actually looked at a Flight payload. It looks like a mix of JSON fragments, dollar-sign-prefixed references, and module pointers that the React runtime silently reassembles into a live component tree. The framework handles it, so nobody questions it.

I’m not sure most teams have thought carefully about what that trust actually implies.

I started pulling apart the Flight protocol after CVE-2025-55182 dropped in December 2025. The security community called it React2Shell, and for good reason. It was a CVSS 10.0, unauthenticated remote code execution vulnerability sitting in the Flight deserialization layer. One crafted HTTP request to a Server Function endpoint, and an attacker had shell access. No credentials needed.

The federal Cybersecurity & Infrastructure Agency (CISA) added it to the Known Exploited Vulnerabilities catalog. Sysdig tied in-the-wild exploitation to North Korean state-sponsored actors deploying file-less implants through the Ethereum blockchain. That’s the kind of CVE that gets your attention.

After spending time in the source (mostly getOutlinedModel and getChunk, which is where the resolution logic that matters actually lives), I realized React2Shell wasn’t a one-off parsing bug. It was a symptom. Flight reconstructs executable references, lazy-loaded components, server RPC endpoints, and async state from a stream of text. That’s a deserialization system.

The attack surface extends well beyond a single missing hasOwnProperty check. This article covers how Flight works on the wire, where the deserialization sinks are, what attackers have already weaponized, and what’s still exposed.

This leads to a ranked, practical set of defenses for your own Server Components: schema validation on every Server Action, the server-only package, cross-site request forgery (CSRF) hardening beyond framework defaults, and an assessment of what the Taint API and Web Application Firewalls (WAFs) provide.

Flight On The Wire #

Open your browser’s Network tab on any Next.js App Router page and look for requests returning Content-Type: text/x-component. That’s Flight. It’s not a single JSON blob. It’s a streaming, line-delimited format where each line is a self-contained “row” that the client-side React runtime processes as it arrives over the connection.

Here’s what a simple Flight payload looks like in practice:

1:I["./src/components/ClientComponent.js",["chunks/main.js"],"default"]
2:J["$","article",null,{"children":"$1"}]
0:D{"name":"RootLayout","env":"Server"}

Row 1 is an import directive. It tells the client to load ClientComponent.js from the bundler’s chunk map. Row 2 is a JSON tree that constructs an <article> HTML element, and the "$1" inside children is a reference back to chunk 1 (the imported component). Row 0 defines the server execution context, marking this as a RootLayout running in the Server environment. Even in this tiny example, you can see the mix of structural data, module references, and cross-chunk pointers that makes Flight different from plain JSON.

The Row Format #

Every row follows the same syntax: <ROW_ID>:<ROW_TAG><PAYLOAD>\n. The row ID is a numeric identifier that other rows can reference. The tag is a single character (or short string) that tells the parser what kind of data follows. The payload is the actual content.

Here are the row tags I found while reading through the source:

Tag	Name	What it does
J	JSON Tree	Serialized virtual DOM nodes, component props, and HTML elements.
M	Module	Metadata for a specific Client Component module or chunk.
I	Import	Tells the client to load a module from the bundler’s chunk map.
HL	Hint/Preload	Instructs the browser to preload resources such as stylesheets or fonts.
D	Data	Server-rendered element context and environment info.
E	Error	Serialized server-side exceptions and error boundaries.

So far, this might look like a benign structured data format with some custom tags, but the real complexity and attack surface live in the prefix system.

The `$` Prefix System #

This is where I started paying closer attention.

When the client-side parser encounters a string value starting with $, it doesn’t treat it as literal text. It intercepts the string, checks the prefix, and routes it through a type-specific resolution path. The parseModelString function in ReactFlightClient.js is where this happens. It’s essentially a big switch statement on the character after $.

Prefix	Type	What the parser does with it
`$`	Model Reference	Resolves to another chunk in the stream (e.g., `$2` points to row 2).
`$:`	Property Access	Traverses into a resolved chunk’s properties (e.g., `$1:user:name`).
`$S`	Symbol	Creates a native JavaScript `Symbol`.
`$F`	Server Reference	Represents a callable Server Action (an RPC endpoint on the server).
`$L`	Lazy Component	Defers component loading until it’s needed in the render tree
`$@`	Promise/Raw Chunk	Returns the internal Chunk wrapper object itself (often acting as a Thenable/Promise), not its resolved value.
`$B`	Blob/Binary	Triggers the blob deserialization handler for binary data.

Every other prefix resolves a chunk and gives you the parsed result. $@ hands you the raw internal Chunk object instead, the wrapper React uses to track resolution state, pending callbacks, and internal metadata (which is why it’s used for Promises and why exploits use it to get a mutable handle). Exposing framework plumbing through the protocol looks like a design mistake to me, though I’d be interested to hear the rationale if there is one.

And $: (property access) is the other critical prefix. It lets the protocol specify a path like $1:user:name, which tells the parser to resolve chunk 1, then access .user, then access .name on the result. That’s arbitrary property traversal driven by data in the stream. If you’ve spent any time auditing JavaScript for prototype pollution, that pattern should feel familiar.

This Is Not Just A Data Format #

Flight is not JSON with extra steps. JSON gives you data. Flight gives you behavior. It reconstructs module references that trigger client-side code loading, creates server action endpoints the client can invoke as RPC calls, sets up Promise chains that the React runtime will await, and builds lazy-loaded component boundaries that execute on demand.

Whether React developers think of it that way or not, the mechanics look very similar to deserialization systems that have historically caused problems. The stream doesn’t just describe what the UI looks like. It instructs the client runtime on what code to load, what functions to call, and what to trust.

If you want to read the implementation yourself, fair warning: the chunk resolution path is miserable to follow. State transitions bounce between helper functions, and the naming obscures what the code is actually doing. I gave up on static reading and just set breakpoints. The key files are react-client/src/ReactFlightClient.js for the client-side parser (look for parseModelString, getChunk, reviveModel, and getOutlinedModel) and react-server/src/ReactFlightServer.js for the serialization side. The reply handler for Server Actions lives in react-server/src/ReactFlightReplyServer.js.

Why Flight Is A Deserialization Sink #

The deserialization pattern is familiar: Java’s ObjectInputStream gave us ysoserial, Python’s pickle executes code on load(), PHP’s unserialize chains __wakeup and __destruct methods, and .NET’s BinaryFormatter was deprecated entirely.

The pattern: deserialize attacker-controlled input → invoke behavior during reconstruction → lose control of execution.

So JavaScript should be immune to this, right? JSON.parse() only produces plain data objects. No constructors fire. No magic methods run. You get back exactly what the JSON string describes, nothing more.

That’s true for raw JSON.parse(). But it stops being true the moment a framework wraps custom deserialization logic around it. And that’s exactly what Flight does.

Prototype Pollution #

JavaScript uses prototype-based inheritance. Every object has a __proto__ link to its prototype, and property lookups walk up this chain. If an attacker injects __proto__ or constructor.prototype as a key during reconstruction, they modify the shared base prototypes that all objects inherit from. Downstream code reads attacker-controlled values without knowing.

Flight’s $: prefix performs property traversal on deserialized objects. The getOutlinedModel function walks colon-separated paths like $1:user:name by iterating through each segment and accessing it on the parent object. If those path segments include __proto__ or constructor, the traversal walks straight up the prototype chain. That’s not a theoretical risk. It’s exactly how React2Shell worked.

Duck Typing and Thenables #

The V8 engine (and the JavaScript spec) treats any object with a .then property as a Thenable. When you await something, the runtime checks for .then and calls it if it exists. No class check. No internal slot verification. If .then is callable, it gets invoked.

Flight resolves chunks asynchronously. If an attacker constructs an object with a manipulated .then property and gets it into the chunk resolution pipeline, the runtime calls the attacker’s function during normal await behavior. The language semantics do the work.

I initially focused on $F because forging Server Action references seemed like the obvious attack surface. After tracing the resolution path, $: property traversal looked much more interesting. I also spent a few hours examining chunk status transitions (pending, blocked, resolved, errored) to see if you could force a chunk into an unexpected state, though that approach didn’t yield any results.

The Core Problem #

These two risks converge in Flight because the protocol doesn’t just deserialize data. It deserializes behavior. The $ prefix system dictates which execution path the parser takes: $F creates a callable server endpoint, $L sets up lazy code loading, $B triggers a blob handler, $@ exposes internal framework state. The parser’s control flow is driven entirely by what’s in the stream.

If an attacker can influence the stream’s content, they control which functions the parser calls, which objects it constructs, and which internal state it exposes.

The Mechanics Of React2Shell #

This is the CVE that proved the theory. CVE-2025-55182, nicknamed React2Shell, is a CVSS 10.0 unauthenticated remote code execution vulnerability in the Flight deserialization layer. One HTTP request, no login required, full shell access.

I want to walk through the entire gadget chain because understanding it reveals how much power the Flight protocol hands to an attacker who can control the stream.

The Root Cause #

The vulnerability sits in getOutlinedModel, a function responsible for resolving deep property paths from the $: reference system. The instance used in the exploit chain lives in the server-side reply handling code (ReactFlightReplyServer.js). When the parser encounters a reference like $1:user:name, it splits on the colons and walks the path segment by segment. Here’s the vulnerable loop:

for (key = 1; key < reference.length; key++)
    parentObject = parentObject[reference[key]];

Two lines. No hasOwnProperty check. No validation that the property exists on the object itself rather than somewhere up the prototype chain. Just parentObject[reference[key]] and move on.

So an attacker supplies $1:__proto__:constructor:constructor, and the loop traverses from a plain JSON object up through Object.prototype to the Object constructor to the Function constructor. Function in JavaScript behaves like eval(). Function("arbitrary code")() executes.

No allowlist on property names. No check for __proto__. I searched reviveModel and the chunk initialization path for any filtering. Nothing.

The Gadget Chain #

Getting from “I can reach the Function constructor” to “I have RCE” requires chaining several Flight protocol features together. The Resecurity write-up covers the full chain in detail; here’s the high-level sequence:

Step 1: Prototype walk to Function.
The $: path __proto__:constructor:constructor walks from any plain object to Object.prototype, then to the Object constructor, then to Function — JavaScript’s built-in eval() equivalent.
Step 2: Raw chunk self-reference.
$@0 returns the raw internal Chunk wrapper instead of its resolved value, giving the attacker a mutable handle on React’s internal state machine.
Step 3: Thenable hijack.
The attacker sets the chunk’s .then to Chunk.prototype.then, so React’s resolution pipeline treats the manipulated chunk as a legitimate Promise-like object and awaits it.
Step 4: Context confusion.
During the second deserialization pass, the payload overwrites _response._formData.get to point to the hijacked Function constructor and places the attacker’s shell command into _response._prefix.
Step 5: Trigger via blob handler.
$B0 invokes the blob handler, which internally calls response._formData.get(response._prefix + blobId) — now equivalent to Function("attacker_shell_command")(). That’s arbitrary code execution with whatever privileges the Node.js process has.

Each step uses a legitimate Flight protocol feature in a way the designers didn’t anticipate. There’s no single “broken” feature. The vulnerability emerges from how these features compose when an attacker controls the input.

Impact #

The numbers on this one are stark:

CVSS 10.0. The maximum possible score.
Unauthenticated and pre-auth. No credentials needed — and the deserialization happens before any application-level auth checks run, so even endpoints behind login walls are exposed.
Single HTTP request. One POST to a Server Function endpoint.
Affected React 19.0.0, 19.1.0, 19.1.1, and 19.2.0, across react-server-dom-webpack, react-server-dom-parcel, and react-server-dom-turbopack.
CISA added it to the Known Exploited Vulnerabilities catalog within days.

What Happened In The Wild #

Exploitation was immediate. Sysdig published research linking EtherRAT deployments to North Korean state-sponsored actors who weaponized the vulnerability within hours of disclosure. EtherRAT is a file-less implant that uses the Ethereum blockchain for command-and-control communication — a technique researchers call “EtherHiding” — making takedown nearly impossible because you can’t seize a blockchain.

Separately, Palo Alto’s Unit 42 documented a backdoor called KSwapDoor that masquerades as [kswapd1] on infected Linux systems, blending into process lists alongside the legitimate kswapd0 kernel swap daemon; their analysis confirms KSwapDoor uses RC4 encryption to protect its internal strings and configuration data, while C2 communications run over AES-256-CFB with Diffie-Hellman key exchange across a P2P mesh network. The speed and sophistication of these campaigns — state-sponsored actors deploying novel implants through a single unauthenticated HTTP request — underscores why a CVSS 10.0 in a deserialization layer demands immediate patching, not triage.

The Fix #

The React team’s patch is clean and targeted. The core change caches the genuine hasOwnProperty method at module load time:

var hasOwnProperty = Object.prototype.hasOwnProperty;

Then every property check in the deserialization path uses .call() to invoke the cached reference:

hasOwnProperty.call(value, i);

Even if an attacker shadows hasOwnProperty on a malicious object, the check uses the original prototype method. The prototype chain traversal that powered the gadget chain is blocked. This fix shipped in React 19.0.1, 19.1.2, and 19.2.1.

The fix is correct. But reading through the patches, I noticed the React team hardened ownership checks while leaving the property traversal model intact. The $: prefix still walks colon-separated paths; it just validates each step now. I think exposing arbitrary property traversal through a network protocol was a design mistake, and the patch treats the symptom. If future bugs emerge, they’ll likely come from this same area.

The framework patch closes the known gadget chain, but it doesn’t change the fundamental dynamic: the Flight protocol still reconstructs behavior — executable references, module imports, RPC endpoints, async state — from a stream of text. That reconstruction happens before your application code runs, before your validation logic fires, before your auth middleware even sees the request. Relying solely on the framework to protect your Server Components means trusting that every edge case in a complex deserialization parser has been found and fixed. The defenses that follow are the practical steps you can take to limit the blast radius on your own.

Defenses, Ranked By Impact #

Some of these close real attack paths. Others mostly make you feel safer than you are. I’ve ranked these from most-to-least impactful based on what I’ve seen in the vulnerability research. If you only have time for one change, start at the top.

1. Input Validation On Server Actions (Zod, Valibot) #

This is the single most impactful thing you can do at the application level. The Flight deserializer processes raw, unvalidated network input before your code takes control. Strict schema validation is your primary defense against whatever the protocol reconstructs.

Put a schema validation call at the very top of every Server Action, before any business logic runs — and I mean before anything, including logging. If you log an argument before validating it, and that argument triggers the stringification bug from CVE-2025-55183, you’ve leaked source code before your validation even had a chance to run.

Zod and Valibot both work well for this. Validate types, shapes, string lengths, numeric bounds, and enumerated values. Reject anything that doesn’t match. Use .safeParse(), not .parse() — the throwing variant can surface internal error details in the response if you’re not careful with your error boundaries.

"use server"
import { z } from "zod"

const UpdateProfileSchema = z.object({
  name: z.string().min(1).max(100),
  email: z.string().email(),
  role: z.enum(["user", "editor"]),
})

export async function updateProfile(formData: FormData) {
  const parsed = UpdateProfileSchema.safeParse({
    name: formData.get("name"),
    email: formData.get("email"),
    role: formData.get("role"),
  })
  if (!parsed.success) return { error: "Invalid input" }
  // proceed with parsed.data, this is now the only shape
  // your business logic ever sees
}

One important nuance: If your Server Action accepts a plain object argument (not FormData), validate the whole argument — don’t destructure first and validate fields individually. Destructuring before validation means you’re already accessing properties on the unvalidated input, which is exactly the kind of operation the Flight deserializer can exploit.

"use server"
import { z } from "zod"

const CommentSchema = z.object({
  postId: z.string().uuid(),
  body: z.string().min(1).max(5000),
})

// Good: validate the raw argument first
export async function addComment(data: unknown) {
  const parsed = CommentSchema.safeParse(data)
  if (!parsed.success) return { error: "Invalid input" }
  await db.comments.create(parsed.data)
}

// Bad: destructuring before validation
export async function addCommentUnsafe(
  { postId, body }: { postId: string; body: string }
) {
  // by the time this runs, you've already accessed properties
  // on the deserialized input
  const parsed = CommentSchema.safeParse({ postId, body })
  // ...
}

If your Server Action doesn’t start with a schema parse, it’s a vulnerability waiting to happen. I’d argue this should be a lint rule — and if you’re running eslint-plugin-react, consider writing a custom rule that flags any "use server" export without a validation call in its first statement.

2. The `server-only` Package #

The server-only package is straightforward and effective.

Import server-only at the top of any file that contains database credentials, raw API calls, internal business logic, or anything else that should never cross the server-client boundary. If a Client Component tries to import that file (directly or transitively), the build fails with a clear error.

import "server-only"
import { db } from "./database"

export async function getUser(id: string) {
  return db.query("SELECT * FROM users WHERE id = $1", [id])
}

The failure mode to watch for is barrel files. If you re-export a server-only function through an index.ts that also exports client-safe utilities, any Client Component importing from that barrel will pull in the server-only module transitively and break the build — or worse, if the barrel doesn’t include the server-only import itself, it may silently let server code through. Keep server-only modules in separate files with their own import paths.

// Don't do this: barrel re-export mixes boundaries
// src/utils/index.ts
export { getUser } from "./users"     // has "server-only"
export { formatDate } from "./dates"  // client-safe

// Do this: separate import paths
// Client Component imports from "src/utils/dates" directly
// Server Component imports from "src/utils/users" directly

It also won’t protect you from data leaking through return values. If a Server Component calls getUser() and passes the full user object (including passwordHash or internalRole) as props to a Client Component, that data rides the Flight stream to the browser. The server-only guard prevents the code from crossing the boundary, not the data the code returns. You must explicitly filter your return shapes.

3. CSRF Protections #

After CVE-2026-27978, relying solely on Next.js’s built-in Origin vs. Host header check isn’t enough. The Origin: null bypass showed that framework-level CSRF protection has edge cases.

For state-changing Server Actions (anything that writes data, deletes records, or modifies permissions), layer your own protections on top of the framework’s defaults.

Cookie configuration.
Set SameSite=Strict or SameSite=Lax on session cookies. If you’re using next-auth or a custom session library, verify this is set explicitly — don’t rely on browser defaults, which vary.

// next.config.js or your auth configuration
cookies: {
  sessionToken: {
    name: "__session",
    options: {
      httpOnly: true,
      sameSite: "strict",
      secure: process.env.NODE_ENV === "production",
      path: "/",
    },
  },
}

Explicit CSRF tokens.
For high-value operations (password changes, role assignments, payment actions), generate a per-session CSRF token on the server, embed it in a hidden form field or custom header, and validate it in the Server Action before proceeding.

"use server"
import { cookies } from "next/headers"
import { validateCsrfToken } from "@/lib/csrf"

export async function deleteAccount(formData: FormData) {
  const token = formData.get("csrf_token") as string
  const sessionToken = (await cookies()).get("csrf_secret")?.value
  if (!validateCsrfToken(token, sessionToken)) {
    return { error: "Invalid request" }
  }
  // proceed with deletion
}

The allowedOrigins gotcha.
Never, under any circumstances, add 'null' to experimental.serverActions.allowedOrigins in your Next.js config (even if the officially advisory is more nuanced, saying “unless intentionally required and additionally protected”). That string literal matches Origin: null — the exact header that sandboxed iframes send — and it reopens the CVE-2026-27978 bypass. If you’re seeing CSRF failures from legitimate requests, the fix is to configure your reverse proxy to set the correct Origin and Host headers, not to weaken the validation.

// Never do this
module.exports = {
  experimental: {
    serverActions: {
      allowedOrigins: ["null"],  // reopens CSRF bypass
    },
  },
}

4. The `hasOwnProperty` Patch #

I covered this in detail in the React2Shell section. The fix is correct, and it completely neutralizes the known gadget chain. It shipped fast, which I respect.

The action item here is to verify you’re actually running a patched version. The RCE fix landed in React 19.0.1, 19.1.2, and 19.2.1. Check your lockfile:

# npm
npm ls react react-dom react-server-dom-webpack

# pnpm
pnpm ls react react-dom react-server-dom-webpack

# yarn
yarn why react-server-dom-webpack

If you see 19.0.0, 19.1.0â€“19.1.1, or 19.2.0, you’re vulnerable to the RCE. Update immediately. And don’t stop there: the DoS fixes (CVE-2025-55184, CVE-2025-67779, CVE-2026-23864) require 19.0.4+, 19.1.5+, or 19.2.4+. If you updated after React2Shell and then stopped paying attention, you may still be running a version vulnerable to the DoS variants.

It’s a reactive patch, not a structural redesign.

Note: More on that in Where This Goes Next.

5. The Taint API #

React’s taintObjectReference and taintUniqueValue functions register objects or strings with the runtime. If tainted data tries to pass through the Flight serializer, it throws an error. The idea is to prevent sensitive data — user records, API keys, tokens — from accidentally leaking into the client.

Here’s how it looks in practice:

import {
  experimental_taintObjectReference as taintObjectReference
} from "react"
import "server-only"

export async function getUserRecord(id: string) {
  const user = await db.users.findUnique({ where: { id } })
  taintObjectReference(
    "Do not pass the full user object to Client Components. " +
    "Select only the fields you need.",
    user
  )
  return user
}

If a Server Component passes the tainted user object as props to a Client Component, React throws it at serialization time with your custom error message. That’s genuinely useful as a development-time guardrail.

The catch — and it’s a significant one — is that taint tracks object references, not data content. Any derivation breaks the tracking:

const user = await getUserRecord(id)

// taint is lost. Spread creates a new object.
<ClientProfile user={{ ...user }} />

// taint is lost. Individual properties aren't tracked.
<ClientProfile token={user.apiToken} />

// taint is lost. Serialization round-trip creates new refs.
<ClientProfile user={JSON.parse(JSON.stringify(user))} />

// taint fires. Same object reference.
<ClientProfile user={user} />

taintUniqueValue works on specific strings (like API keys), but it’s also reference-based. If the same key value appears in a different variable, the taint doesn’t follow.

Think of taint as a development guardrail, not a security boundary. It catches honest mistakes: a developer accidentally passing a full user object to the client. It won’t stop an attacker who can influence what gets serialized, and it won’t survive routine data transformations that your own code performs. It’s a useful defense-in-depth layer, but shouldn’t be your primary boundary.

6. WAFs #

Web Application Firewalls can add a detection layer for known attack patterns. They can inspect POST requests carrying the Next-Action header, block payloads containing constructor:constructor or __proto__ chains, and flag error responses containing E{"digest" patterns that indicate the server is leaking internal error details.

If you’re running a WAF, here are specific patterns worth adding:

# Block prototype pollution attempts in request bodies
Rule: body contains "__proto__" OR "constructor:constructor"
Action: BLOCK
Scope: POST requests with header "Next-Action"

# Flag potential Flight error leakage in responses
Rule: response body matches /E\{"digest":"[^"]+"/
Action: LOG + ALERT
Scope: responses with Content-Type "text/x-component"

# Block excessively large Server Action payloads
Rule: Content-Length > 1MB for POST with "Next-Action" header
Action: BLOCK (mitigates CVE-2026-23864 zipbomb vector)

But attackers know about WAF inspection buffers, and they’re usually around 128KB. Prepend 130KB of padding before the malicious payload, and the WAF inspects the padding, finds nothing, and lets the request through. Chunked Transfer-Encoding tricks accomplish the same thing.

The failure mode is treating WAF coverage as a security boundary rather than a noise-reduction layer. WAFs catch automated scanners and low-effort attacks, and that has real value. But a motivated attacker will bypass them with padding or encoding tricks. The defenses that actually stop sophisticated attacks are the ones earlier in this list: validating input before it reaches your business logic, keeping sensitive code off the wire, and staying on patched versions.

What Came After React2Shell #

React2Shell wasn’t the end of it. The security audits that followed the December 2025 disclosure shook out a series of related vulnerabilities in the same deserialization surface. None of them are as severe as the original RCE, but they’re worth tracking because some of them required multiple rounds of patching.

CVE	CVSS	Type	Description	Fixed In
CVE-2025-55184	7.5	DoS	Infinite recursion of nested Promises in Server Function deserialization. Hangs the Node.js event loop.	19.0.2, 19.1.3, 19.2.2
CVE-2025-67779	7.5	DoS	Incomplete fix for CVE-2025-55184. Same loop via edge cases the first patch missed.	19.0.4, 19.1.5, 19.2.4
CVE-2026-23864	7.5	DoS/OOM	Unbounded request body buffering and zipbomb-style decompression. Memory exhaustion. Disclosed Jan 2026.	19.0.4+, 19.1.5+, 19.2.4+
CVE-2025-55183	5.3	Info Disclosure	Crafted requests reflect Server Function source code when the function stringifies an argument.	19.0.1, 19.1.2, 19.2.1
CVE-2026-27978	5.3	CSRF Bypass	Next.js treated `Origin: null` (sandboxed iframes) as “missing” instead of “cross-origin.”	Next.js 16.1.7

The DoS pair (CVE-2025-55184 and CVE-2025-67779) is a textbook example of why deserialization parsers are hard to patch correctly. The first fix shipped, researchers found edge cases it missed, and a second round was needed. CVE-2026-23864 added a third DoS vector through unbounded memory allocation rather than CPU exhaustion. (See the defenses section above for specific version checks.)

CVE-2025-55183 is the sneaky one. It’s a source code exposure bug that triggers when a Server Function calls JSON.stringify (or any implicit stringification) on one of its arguments. Developers do this constantly for logging, debugging, or error reporting.

The attacker sends a crafted argument that, when stringified, causes the deserialization parser to reflect the function’s own source code back in the response. Business logic, database queries, and any hardcoded secrets sitting in Server Action files become readable by anyone who can send an HTTP request.

CVE-2026-27978 is a different class of bug entirely. It’s a CSRF bypass in Next.js’s Server Action handling. Next.js validates that the Origin header matches the Host header to prevent cross-site request forgery. But when a request comes from a sandboxed <iframe>, the browser sends Origin: null.

The Next.js parser in action-handler.ts treated the string 'null' as a missing origin rather than an explicit cross-origin indicator. So an attacker could embed a form inside a sandboxed iframe, submit it, and invoke Server Actions using the victim’s authenticated session cookies. Fixed in Next.js 16.1.7.

What’s Still Exposed #

The CVEs above have patches. But some of the risk is structural, baked into how Flight is designed to work.

Man-In-The-Middle (MITM) On The Flight Stream #

If an attacker can sit between server and client (CDN compromise, cache poisoning, rogue proxy), modifying the Flight stream in transit looks feasible. The format is plain text with a predictable structure.

Assuming stream control, an attacker could alter $I (Import) rows to redirect component loading to a different module in the webpack chunk map. They could inject $F (Server Reference) tags to embed hidden RPC triggers in the rendered UI. They could modify D (Data) rows to change component props, and if the target component uses dangerouslySetInnerHTML, that’s a direct XSS vector.

Flight escapes $ prefixes in user-supplied strings to prevent data from being interpreted as protocol instructions. But that only applies to data flowing through the serializer. A MITM attacker writes raw protocol directly into the stream. The escaping doesn’t help.

Server Action Enumeration #

Server Action IDs are obfuscated hashes generated at build time. They look random. But server-reference-manifest.json maps every action ID to its source implementation. A public manifest hands an attacker a complete API map. This exposure usually stems from misconfigured hosting, an exposed .next directory, or path traversal.

Known action IDs expose Server Actions to standard IDOR and parameter tampering attacks. An attacker can forge direct requests with manipulated arguments. Developers often trust these inputs blindly because they originate from React’s internal machinery. The architectural consequences of that misplaced trust will be the focus of my next piece.

Encrypted Closure Tampering #

When a Server Action captures variables from its surrounding scope (closures), Next.js encrypts them before sending to the client. The key is in NEXT_SERVER_ACTIONS_ENCRYPTION_KEY, AES with a base64-encoded key (16, 24, or 32 bytes). decryptActionBoundArgs handles decryption on each invocation.

By default, this key regenerates every build. But multi-server setups often use a static key. If an attacker gets file read access (path traversal, SSRF), they extract the key, decrypt the closure state, modify it (changing a userId, a role, a query parameter), and re-encrypt. The server accepts the forged closure as legitimate.

Supply Chain Activation via Module IDs #

I haven’t demonstrated this end-to-end, but the theory is straightforward.

Flight references client components by module ID, something like ["360","static/chunks/app/page-7f3480.js"]. The bundler assigns these IDs at build time based on the module graph. A compromised npm package sitting in node_modules as a transitive dependency gets bundled into a chunk but never loaded because no component references it. Inert.

But if an attacker injects $I import references into the Flight stream (via MITM, cache poisoning, or server-side injection), the parser should load that dormant module. There may be chunk-level validation I’m not seeing. But if the module ID is valid and present in the manifest, I don’t see what stops it. The attack doesn’t require the package to be imported anywhere in your code. It just needs to exist in the bundle output.

This Has Happened Before #

React Flight isn’t the first framework to invent a custom serialization format for server-client communication and then discover it’s an attack surface. And it won’t be the last.

Google Web Toolkit (GWT) used a custom RPC protocol to sync Java objects between browser and server. BishopFox demonstrated that attackers could manipulate the wire format to achieve arbitrary deserialization; GWT eventually disabled binary serialization entirely. It took years.

Java Server Faces (JSF) and ASP.NET both serialized ViewState to the client as a hidden form field. When cryptographic signing was weak or missing, attackers tampered with the serialized state and achieved remote code execution. Microsoft and Oracle patched it repeatedly. The underlying pattern kept resurfacing.

The pattern is always the same: a framework invents a custom wire format to move rich, stateful, sometimes executable data between server and client. The designers assume the server is the sole producer of that data and the client is a trusted consumer. Then someone demonstrates that the wire format can be manipulated in transit, or that the server can be tricked into deserializing attacker-controlled input. React Flight is the latest entry in this pattern. It is not an anomaly.

Where This Goes Next #

The React Flight protocol solves a genuinely hard problem: streaming interactive component trees from server to client in a way that enables progressive hydration, async data loading, and server-driven code splitting. It works. I don’t want to lose sight of that.

But it works by serializing executable references, async state, module pointers, and RPC endpoints over a streaming text protocol, and then trusting the structure of that stream on both ends. The React team has patched the known gadgets. The hasOwnProperty fix is correct. The DoS fixes are in place. The source code exposure bug is closed.

I think exposing arbitrary property traversal and executable Thenable reconstruction through a network-facing protocol was a design mistake. $:, $@, and $B are powerful internal primitives that were reachable through a parser that didn’t validate ownership of the properties it traversed. One check was missing, and the result was CVSS 10.0.

As more frameworks adopt server-driven UI patterns, the industry is going to need stronger primitives than “the server is trusted”: cryptographic validation of serialized payloads, signed component trees, and content integrity checks on the Flight stream itself.
“

Hoping the parser handles every edge case hasn’t worked historically, and I don’t see why it would start working now.

The code is in react-client/src/ReactFlightClient.js. If you ship Server Components, read it. Know what your framework is trusting on your behalf.

Why Accessibility Is An Operational Capability, Not A Feature

noreply@blogger.com (H) — Fri, 24 Jul 2026 07:53:00 +0000

Teams can generate UI faster than ever, but they still have to guarantee that what they ship is usable, secure, and maintainable. Accessibility as an operational capability rather than a compliance checklist or end-of-project audit, and what that looks like in practice.

We know that right now, a senior engineer is shipping a checkout flow they “built” in a single afternoon. AI assistant does the heavy lifting, happy path runs clean, and a rotating chevron spins on the order summary. Two weeks later, engineering gets a notice from customer support: a blind customer using a screen reader can’t complete the purchase because the “Pay Now” control is a <div> with a click handler. No role. Not focusable. Not working.

That gap — between code that runs and a product people can actually use — is becoming one of the defining engineering challenges of the AI era. Teams can generate UI faster than ever, but they still have to guarantee that what they ship is usable, secure, and maintainable.

Accessibility sits right in the middle of that problem.

This is not an article about compliance checklists or end-of-project audits. It’s about engineering systems. Specifically, why accessibility should be treated as an operational capability — alongside privacy, security, reliability, and observability — and what that looks like in practice.

The Audit Trap

For years, the default way to “do” accessibility was the one-time, audit-only approach: hire a firm, get a list of 200 findings, fix some of them, file the report. A lot of teams have now moved beyond this model — and the reason is worth looking into.

Audits do matter. For sales, procurement, governance — they’re essential. When a buyer asks for a VPAT or an ACR, you need one. When legal asks if you’re meeting requirements, you need documentation. Audits serve those purposes well.

But audits don’t help you build accessible features during sprint planning. Audits can cost points during a sprint. They don’t catch problems before merge requests. They don’t scale with deployment velocity. The mistake, essentially, is tackling accessibility as a snapshot when you really need constant monitoring. Six months after the audit, the product has shipped dozens of releases, multiple new features, and a redesigned nav. The report is now fiction. Compliance is not a state you reach — it’s a state you maintain, and complexity fights you the whole way.

The WebAIM Million report, which scans the top one million home pages every year, found that 95.9% of pages had detectable WCAG failures in its 2026 run, with an average of 56.1 errors per page. The number of page elements jumped more than 20% in a single year, likely driven by AI-enabled development and ‘vibe coding’ — and more elements mean more places to break. Accessibility debt behaves exactly like technical debt: every inaccessible component you ship becomes a future remediation project, and the interest compounds.

Any strategy that treats accessibility as a periodic event rather than a continuous property of the system is going to lose.

The AI Problem Nobody Wants To Name

With the scale at which teams now generate UI, the gap doesn’t just persist; it multiplies.

Start with how fast this arrived. In February 2025, Andrej Karpathy coined “vibe coding” — a way of working where you “fully give in to the vibes” and “forget that the code even exists”. You describe intent, the model generates, you accept the diffs without reading them. It was meant for weekend projects. It did not stay there. Y Combinator reported that 25% of its Winter 2025 batch had codebases that were 95% AI-generated.

Models don’t land on non-semantic markup by accident — three forces push them there. Most React code on GitHub uses non-semantic “soup”, so that’s what the models learn. Human reviewers and evaluators judge output visually, so the feedback loop rewards looks, not semantics. And <div onClick> is fewer tokens than <button aria-expanded="true" ...>, so absent a constraint, the model takes the cheap path.

Here’s the thing about AI-generated UI: it’s inaccessible by default. Not occasionally — by default. A developer writing in Frontend Masters tested AI-generated React components across multiple tools and documented the pattern. A typical AI-generated sidebar had ten distinct accessibility failures in twenty-nine lines: no landmark, no heading, no list structure, elements with click handlers instead of buttons, no aria-expanded, no keyboard handling, and unlabeled icons. The accessibility tree — the structure screen readers actually read — came back as flat, unstructured text. “Same pixels” as the author put it. “One is a door. The other is a painting of a door”.

Now connect this to security, because the two failures come from the same root. Veracode’s 2025 GenAI Code Security Report tested large language models across dozens of coding tasks and found that a large fraction of AI-generated code introduced security vulnerabilities — including OWASP Top 10 flaws. Cross-site scripting failures were particularly common, and security performance did not meaningfully improve with newer, larger models. The issue wasn’t model intelligence. It was process: developers generating code without specifying security constraints and accepting output without systematic verification.

The same shortcut that skips the security review skips the accessibility review. At scale, AI won’t close the accessibility gap — it has industrialized the very thing that creates it.

The fix is not to ban AI. Your developers are already using it. The fix is to constrain it and verify it — to treat AI as a very fast teammate who always needs guardrails.

Velocity and Accessibility Are Not Enemies #

This is usually where someone says, “Guardrails? Sounds great, but they will slow us down.”

In practice, the opposite tends to be true.

Shift-left is the entire DevOps thesis, and it applies cleanly here. An accessibility issue caught during design review is a comment. The same issue found in production is a remediation project.

Catching an accessibility issue as a component is built takes minutes. Fixing one after the fact — discovering it in an audit, diagnosing the root cause, restructuring the markup, applying the necessary fix, writing tests — can easily take hours. Multiply that across hundreds of findings from a late-stage audit, and you have weeks of unplanned work that earlier automated checks — whether in design reviews, development workflows, or CI — could have prevented.

Teams that integrate accessibility into everyday workflows avoid the expensive surprises: emergency audits, remediation sprints, procurement blockers, and redesigns that quietly break core user journeys. Accessibility doesn’t reduce velocity. Unexpected work reduces velocity. In-flow accessibility is one way of eliminating unexpected work.

What Enterprise-Ready Actually Looks Like

The organizations that scale accessibility successfully do not rely on heroes. They rely on systems.

The highest-leverage place to start is the design system. One accessible component can be reused thousands of times. The GOV.UK Design System is a useful example: components undergo both automated and manual testing using assistive technologies such as JAWS, NVDA, VoiceOver, and TalkBack. The team is explicit about the limits of automation and supplements tooling with user testing involving people with disabilities. They’re equally clear that using the design system doesn’t “magically” make a service accessible; it just gives you a higher starting point.

Accessibility becomes infrastructure. That’s the lesson.

From there, it moves into the engineering workflow:

Accessibility requirements are included in the Definition of Done.
Pull request reviews include explicit accessibility checks.
Interactive controls use semantic elements (<button>, <a>) by default.
Keyboard navigation and focus management are treated as standard engineering concerns, not optional polish.

Finally, accessibility becomes enforceable through automation:

eslint-plugin-jsx-a11y catches common issues before code is committed.
LevelCI, Pa11y, and similar tools provide automated testing in CI/CD pipelines.
@storybook/addon-a11y surfaces issues during component development.

At that point, accessibility stops depending on memory and starts depending on the process. It becomes part of your platform.

Patterns That Actually Scale

A few implementation patterns consistently show up in teams that do this well.

Constrain AI Before It Generates

Instead of fixing accessibility after generation, bake requirements directly into tooling through Cursor rules, Copilot instructions, or repository-level standards. Tell the model to use semantic HTML. Tell it when to use buttons versus links. Tell it to expose the state and labels correctly. Models follow persistent constraints far more reliably than one-off prompts.

Stop Hand-Rolling Complex Widgets

Comboboxes, menus, tabs, modals, and similar controls routinely become accessibility hotspots. Libraries such as Radix UI, React Aria, and Headless UI already solve many of these problems. The scalable approach is not about repeatedly implementing accessibility correctly. It’s inheriting accessible behavior from well-tested primitives.

Capture Accessibility During Design Handoff

Focus order, labels, heading hierarchy, and interaction states should be specified before implementation begins. If accessibility requirements are absent from the design artifact, they are often absent from the final product. A simple memo at design handoff — what is the tab order, what are the labels, what happens on error — removes a huge amount of guesswork later.

None of these patterns is exotic. They’re just DevOps and platform thinking applied to accessibility.

The Broader Business Impact

Engineering leaders rarely prioritize accessibility solely because of regulations. But regulations, procurement requirements, user retention, and product quality all point in the same direction.

Legal pressure continues to increase. Digital accessibility lawsuits in the United States have stayed in the thousands per year, and they are not limited to large enterprises. The European Accessibility Act is now enforceable across the EU, applying to e‑commerce, banking, ticketing, telecoms, and more, regardless of where the company is headquartered. The message is clear: accessibility is no longer a “nice-to-have” in the eyes of regulators.

But compliance is only part of the story. The bigger story is the market you leave on the table. The World Economic Forum (December 2023) estimates that the world’s 1.3 billion people with disabilities, “along with their friends and family, has a spending power of $13 trillion”; disabled consumers alone control roughly $8 trillion in annual disposable income, per the Valuable 500.

In the UK alone, the Click-Away Pound Report 2019 found the “Click-Away Pound has risen to £17.1 billion” — more than 4.9 million users with access needs who abandon inaccessible sites and spend elsewhere, up almost 45% from £11.75 billion in 2016. People don’t file a bug report. They leave and buy from a competitor.

There is also a procurement reality that turns accessibility from a cost into a moat. If you sell B2B or to government, you will increasingly be asked for proof of accessibility — VPATs/ACRs or equivalent documentation. According to Level Access’s Seventh Annual State of Digital Accessibility Report, 75% of organizations now require proof of accessibility at least most of the time when purchasing digital products — essentially unchanged from 74% in the previous report, but with a notable shift towards stricter enforcement, as those that always require it rose from 27% to 31%. A strong ACR accelerates the sales cycle; a weak one, or none at all, creates redlines that stall or kill it. For some buyers, this is a hard requirement before your product can even enter evaluation. A strong accessibility story accelerates the sales cycle. A weak one creates redlines that stall or kill it.

Step back and the deeper pattern is clear: accessibility is a proxy for engineering maturity. A team that ships semantic HTML, manages focus, exposes state correctly, and tests it in CI is a team that has its house in order. The same discipline that produces an accessible component produces a maintainable, testable, less buggy one.

For dev and product leaders, that’s the real business case: accessibility work is platform work. It pays off every time a feature ships faster and more smoothly, with less rework, than it otherwise would have.

Systems, Not Sprints

If you take one thing from this, make it this: accessibility doesn’t come from an audit, a hero, or a heroic remediation sprint before launch. It comes from systems.

An accessible design system so components start right. A Definition of Done so they stay right. Automated testing and CI gates so regressions fail the build. Governance, so someone owns it. Guardrails for AI-assisted development so your fastest tool stops being your biggest liability.

None of those practices is particularly glamorous. That’s exactly why they work. They’re the same kinds of boring, reliable systems you already trust for security, reliability, and performance.

But there’s one thing no tool on that list can do. No linter, no automated scanner run, no dashboard will ever tell you what it’s actually like to use your product as a blind person with a screen reader, or to navigate your checkout with a keyboard because a tremor makes a mouse inoperable. So build the systems — you need them, and they’re the only way accessibility survives contact with a real release schedule. But test with real users with disabilities regularly. The first time you sit behind someone using JAWS to fight through a form your team thought was “done”, something changes. The tooling tells you whether you passed. A real person tells you whether it actually works.

Accessibility is not a feature. It’s an operational capability. Treat it that way, and you get something dev and product leaders already care about: a faster, safer, more reliable way to ship software.

M Office and imilar free

noreply@blogger.com (H) — Thu, 23 Jul 2026 08:42:43 +0000

Yes. Apache OpenOffice is free, but it is no longer the best choice because development is much slower than other office suites. Most people now recommend LibreOffice instead. (LibreOffice)

Here are the best free alternatives to Microsoft Office:

LibreOffice ⭐ (Best overall)
- Completely free and open source
- Includes Writer, Calc, Impress (like Word, Excel, PowerPoint)
- Excellent for offline use
- Best-maintained OpenOffice successor. (LibreOffice)
ONLYOFFICE
- Free desktop version
- Interface is very similar to Microsoft Office
- Strong compatibility with DOCX, XLSX, and PPTX. (OnlyOffice)
WPS Office
- Free version available
- Modern interface similar to Microsoft Office
- Includes built-in PDF tools
- Some advanced features require a paid version. (explore.wps.com)

Recommendation

For most users: LibreOffice
For the closest Microsoft Office experience: ONLYOFFICE
For a modern interface: WPS Office

If you're using Windows 11, I recommend ONLYOFFICE or LibreOffice.

Here's a detailed comparison of Microsoft Office, LibreOffice, Apache OpenOffice, ONLYOFFICE, and WPS Office.

Feature	Microsoft Office	LibreOffice	Apache OpenOffice	ONLYOFFICE	WPS Office
Price	Paid (Microsoft 365 or one-time purchase)	Free	Free	Free (Desktop), paid business features	Free with ads, Premium available
Open Source	❌	✅	✅	✅ (Desktop Community Edition)	❌
Word Processor	Word	Writer	Writer	Document Editor	Writer
Spreadsheet	Excel	Calc	Calc	Spreadsheet Editor	Spreadsheets
Presentation	PowerPoint	Impress	Impress	Presentation Editor	Presentation
Database	Access (Windows)	Base	Base	❌	❌
Email Client	Outlook	❌	❌	❌	❌
PDF Export	✅	✅	✅	✅	✅
PDF Editing	Limited	Basic	Basic	Good	Good
Microsoft File Compatibility	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Ribbon UI	✅	Optional	❌	✅	✅
Works Offline	✅	✅	✅	✅	✅
Cloud Collaboration	⭐⭐⭐⭐⭐	Limited	No	⭐⭐⭐⭐	⭐⭐⭐⭐
Macros/VBA Support	Excellent	Good (not fully compatible)	Basic	Limited	Limited
Regular Updates	Very frequent	Frequent	Infrequent	Frequent	Frequent
Best For	Professional/business	General users	Legacy users	Office compatibility	Casual users

Pros and Cons

Microsoft Office

Pros

Best compatibility with DOCX, XLSX, PPTX
Advanced Excel features
Outlook, Access, OneNote
Excellent collaboration with OneDrive and Teams

Cons

Paid subscription or license
Closed source

LibreOffice

Pros

Completely free
Open source
Powerful Writer and Calc
No ads
Frequent updates

Cons

Interface feels less modern
Some complex Microsoft Office documents may not look identical

Apache OpenOffice

Pros

Free and open source
Stable for basic use

Cons

Much slower development
Fewer features
Lower Microsoft Office compatibility
Generally replaced by LibreOffice for most users

ONLYOFFICE

Pros

Very similar interface to Microsoft Office
Excellent DOCX/XLSX/PPTX compatibility
Free desktop version
Good collaboration features

Cons

Fewer advanced spreadsheet features than Excel
Database and email applications are not included

WPS Office

Pros

Attractive, Microsoft-like interface
Very good compatibility
Lightweight
Built-in PDF tools

Cons

Free version includes ads
Some features require Premium
Closed source

Feature Ratings (out of 10)

Category	Microsoft Office	LibreOffice	OpenOffice	ONLYOFFICE	WPS Office
Ease of Use	10	8	7	10	9
File Compatibility	10	8	7	9	9
Performance	9	8	7	9	9
Features	10	9	7	8	8
Security	10	9	8	9	8
Updates	10	9	5	9	9
Value	7	10	10	10	9

Which one should you choose?

Best overall (free): LibreOffice
Best Microsoft Office alternative: ONLYOFFICE
Best for Microsoft Office compatibility: Microsoft Office
Best lightweight choice: WPS Office
Not generally recommended for new users: Apache OpenOffice, because it receives updates much less frequently than LibreOffice and has fallen behind in features and compatibility.

If your main goal is to replace Microsoft Office without paying, LibreOffice and ONLYOFFICE are the strongest options today.

Users Don’t Need More Tools: They Need Seamless Integrations

noreply@blogger.com (H) — Thu, 23 Jul 2026 08:41:13 +0000

A closer look at why users don’t need more tools in their daily lives. What they need are seamless integrations of useful features to match already existing, established mental models.

We often hear about shiny new tools that change everything (yet again). But in practice, most people don’t need more tools to deal with in their daily lives. What we actually need are better integrations of useful capabilities that neatly align with our existing and established mental models.

Users don’t get excited about shiny new “smart” workflows, or navigating Terminal commands, or jumping between endless back-and-forth chat interactions. They need seamless integrations of useful features to address problems with high severity, high frequency, and a high level of frustration.

Now, that’s useful: seamless integration of AI features when creating new folders. By Karthikeya GS.

1. AI-First vs. Quiet AI

I’ve always been puzzled by the notion of “AI-first” products. They might speed up production, but we need to know really well first what we actually want to build. AI-first often doesn’t account for years of small and big design decisions that have shaped expectations and mental models over the years.

A neat Claude Excel integration, with users studying specific rows or columns, instead of switching between tools all the time.

I love the notion of “Quiet AI”. These are tools that are mostly invisible, sit in the background, and do small tasks on the user’s behalf. They never scream for attention but happily assist in repetitive, frustrating tasks that can easily be automated or assisted with a smart helper.

Excellent examples of Quiet AI include Claude’s integration within Microsoft Excel, PowerPoint, and Word, providing assistance in context without disrupting the user’s workflow.

2. Folder Instructions For AI Actions #

So no wonder that I absolutely love the idea of folder instructions! There, users can define what a folder is supposed to do, based on the purpose they created it for. It sounds much more complicated than it actually is.

Users define instructions, choose system rules, and the system takes care of the task.

The instructions define what the folder is for, how files should be organized, how sub-folders should behave, and what actions can happen inside. Instead of manually maintaining a folder, you set its intent once and let the system follow it.

It’s a seamless integration of AI helpers just when and where users want and need it. With permissions and actions locally scoped to that specific folder on the user’s machine, unless the user extends access, permissions, or system rules on their own.

Users could automate tasks where the work actually happens, e.g., generating summaries on the fly.

Here are some useful examples:

For a passport renewal, get the form and collect all the documents I need for it. Inform about missing documents, and fill out the form to the best of your abilities.
When new invoices are added to the folder, rename them according to the sequence, sort them by invoice number, and organize them in folders by client.
When a new PDF is added to the folder, generate a summary, send it to my pocket, and send me a notification via email.

Note: For a deeper dive into this concept, you can jump to Karthikeya GS’s wonderful post “Folder Instructions: Instructions For System-Level AI”.

Wrapping Up

User’s value doesn’t emerge from users having to juggle between multiple applications, views, and sources every few minutes. That’s when they are slowed down, and that’s when they make mistakes.

It comes from helping users do the work they need to do — by reducing frustrations, slowdowns and mistakes, and taking care of tasks that otherwise would take too much time and too much effort to complete well.

Yet again, seamless integrations — a very underused but incredibly impactful way to deliver value fast, without adding the burden of installing and learning yet another tool.

When It Makes Sense To “Block” The Main Thread

noreply@blogger.com (H) — Thu, 23 Jul 2026 06:37:07 +0000

The common rule of thumb is to never “block” the browser’s main thread when running JavaScript tasks. But is this a hard rule? \ describes a use case he encountered involving a screenshot extension where he made an exception to the rule and decided that blocking the main thread was absolutely the right thing to do.

We’ve all heard of the sacred rule in modern web development, the rule never to be broken. The rule of “Never block the main thread.”

You almost can’t miss it as a web developer; it’s in almost every performance guide, and to be fair, it is good advice. We all know the browser’s main thread is single-threaded, meaning it can only do one thing at a time.

Plus, as we know, the main thread isn’t ours alone; we share it with the browser’s rendering engine, input handlers, and other critical tasks. As a result, the less time we hold onto the main thread, the more responsive an app feels. That leads us to share tasks with background workers as we’ve convinced ourselves there should be a hard line between the UI and any computation, and that line shouldn’t be crossed.

And that is what a “recommended” architecture looks like.

But I dare say that *sometimes*, moving the data to a worker is slower than just letting the main thread do the work.

I found this out a few months ago while building a Chrome extension with screenshotting features called Fastary. I kept finding a latency of about 2 to 3 seconds in all my testing, even after using an Offscreen Document (a background process in Chrome extensions) to handle the canvas operations. A screenshot task should feel instant without lag, after all.

It is quite ironic that by reflex, we move work away from the main thread to avoid freezing the UI, but sometimes the act of moving that work (e.g., serializing, copying, and deserializing) can also freeze the UI. And sometimes the recommended approach of letting the background do the work can be slower than just doing the work on the main thread.

Let’s talk about that.

The Architecture Of Browser Context Isolation

To put things in perspective, let’s understand why we isolate browser contexts and how they communicate with each other, with emphasis on the communication part.

A browser is more than a single environment. Different environments are running at the same time, each having its own memory space, what it can access, and rules:

The main thread is what we are most familiar with; this is where JavaScript logic runs, where the DOM lives, where styles get rendered, and where users interact.
The Web Workers are separate threads that can also execute JavaScript without DOM access. We mostly use this for heavy data tasks.
The Service Workers are network-related proxies in charge of intercepting network requests and can even run when the page is closed.
And then there are Chrome extension contexts, where we have background service workers, content scripts, and Offscreen Documents (the relevant ones for this article).

Each one of these is isolated from the others. A web worker or background script lives in a different memory space from the main thread. They cannot just reach and read each other’s variables or logic, and this is known as the “shared-nothing” architecture.

How do these isolated environments communicate? They explicitly message each other back and forth using APIs, like postMessage().

The Structured Clone Algorithm

postMessage() tells the browser to take a piece of data and deliver it to the context that requested it. But to do this, the browser relies on the Structured Clone Algorithm (SCA).

You’re probably familiar with JSON.stringify(). SCA is similar, but much stronger and smarter. In its simplest form, SCA is a deep, recursive copy operation, i.e., cloning. It walks through the entire data structure it is given, clones every single value, serializes it into a transportable format, ships those bytes to the target contexts, and then reconstructs the original object on the receiving side.

SCA is fast, or maybe fast-ish… For a small regular config object like {theme: "dark"}, it is imperceptible; you don’t even notice it. The story changes, however, when dealing with heavy data because the SCA is a synchronous blocking O(n) operation, i.e., the cost increases linearly with the size of your data.

Let’s put that into perspective. A user clicks a button, and internally, an 8MB image payload is sent to a background worker for processing. When you call postMessage(), the main thread must immediately stop what it is doing to run this serialization and copying process.

So, if the time it takes to pack, ship, unpack the data, and go back to the start is longer than the time to just process the data on the main thread, why not do that instead?

What About Transferable Objects?

I’m sure some of you are already thinking, “Why not just use Transferable objects?” And that is a valid point. Let’s talk about that.

Developers who really pursue ultra-high-performance web apps usually use Transferable objects (e.g., ArrayBuffer, ImageBitmap, or MessagePort) to bypass the Structured Clone Algorithm. This is because when you transfer an object, you’re not making a copy (like SCM). Instead, the browser switches ownership of the data from one context to another.

The browser performs a hand-off whereby the sending context loses access to the data instantly, and the receiving context takes full control. It is actually insanely fast. According to Chrome Developers’ benchmark, transferring a massive 32MB ArrayBuffer can take under 7ms, compared to about 300ms when cloning with SCM. That’s a 43x speed boost.

Structured cloning vs. Transferable Objects by Chrome Developers. (Image source: Chrome for Developers) (Large preview)

But like all good things, there are downsides. To name a few:

You lose it once you send it.
If the UI still needs that data (like to show an image preview), you can’t access it anymore.
Not all data is transferable.
A plain JS object is not. A Blob is not. Even a Base64 string is not.
API limitations.
In the context of browser extensions, Chrome’s internal messaging (chrome.runtime.sendMessage) traditionally forces everything through JSON serialization.

So, as far as my screenshot extension went, Transferable objects were not an option.

Why We Isolate Contexts Anyway

Why do we even bother isolating contexts at all? Why not just leave it all to the main thread?

Offloading long-running CPU tasks to a background thread is absolutely the right thing to do. The browser needs to paint a new frame every 16.6ms to keep things fluid; that means any task that takes >50ms is generally considered “long”. Offloading to the background is absolutely the right thing to do.

The issue, however, is that we’ve turned this “never block the main thread” into an absolute rule, without asking is this task expensive to process or expensive to move?

I have come to realize now that the rule is less “never block the main thread” than “never block the main thread for too long.”
“

When The Right Architecture Is The Wrong Architecture

My goal with the Fastary extension was to make it feel like a native app, running as smoothly and instantly as you would expect a native app to.

As you already know, I took the recommended approach to use the Offscreen Document to handle DOM work in the background. But to my surprise, that took a different turn.

The Offscreen Document API is a clear winner. You create a hidden, undisplayed document that runs entirely in the background. It has a DOM and supports Canvas. For example, if I want to crop a screenshot, stitch multiple screenshots together, perform heavy image manipulation, or add a watermark, Offscreen Document was made for that.

Turns out that was not the best approach. This was my architecture:

The background Service Worker captures a screenshot with chrome.tabs.captureVisibleTab(), which returns a Base64-encoded data URL string.
The background Service Worker uses chrome.runtime.sendMessage() to ship this image payload to the Offscreen Document.
The Offscreen Document receives the image, loads it into an <img> element, then draws it onto a canvas before it applies the user’s crop coordinates, encodes the result, and sends the processed image back to the background worker.

But when I tested it, the screenshot didn’t feel instant. As I said earlier, there was a consistent 2–3 second lag.

I figured out that when captureVisibleTab() takes a screenshot, it returns a Base64 URL string, and on a standard 1080p screen, that string could be approximately 1MB or more, depending on how detailed the image is. It gets even more interesting on modern Retina displays (e.g., MacBooks) as they tend to automatically double the image’s size by default.

Keep in mind that since the image payload could be doubled and extension messaging relies on JSON serialization (as of this writing), we potentially deal with massive synchronous communication that costs an entire round trip.

The image string data is JSON-serialized at least twice: once when going into the Offscreen Document and once coming back out with the processed results to the background worker. The actual image processing (cropping) done inside the Offscreen Document was fast, no doubt, but I can’t say the same about the transfer overhead.

The Retina High-DPI Problem

As if the latency itself wasn’t enough, I noticed a rather subtle bug — which, now that I think of it, was more of my ignorance. After a screenshot was taken, the crop result was completely off in a way that either weirdly scaled the image or resulted in incorrect coordinates.

It turns out that when a user selects a region to crop, the content script gets the box coordinates using getBoundingClientRect(), which is measured in CSS pixels; this is what the DOM uses. But when the screenshot is captured natively in Chrome, the browser doesn’t crop it automatically; it instead uses the physical hardware pixels to get the full screen capture. And the browser uses devicePixelRatio (DPR) to know how many physical pixels should represent one CSS pixel. Basically, if a user on a Retinal display (DPR = 2) highlights an area of 400x300 CSS pixels, the actual captured image area is 800x600 physical pixels.

Note: One CSS pixel is equal to 1 physical pixel (DPR of 1) on a standard monitor. On a Mac Retina display or a modern 4K monitor, however, the DPR is usually 2 or 3.

For an accurate crop, I needed to apply these two different measurement systems with the right DPR, i.e., scale the crop coordinates by the DPR. But remember, Offscreen Documents have no physical display. Processing any image would have a default DPR equal to 1. To fix this, I would have to capture the exact devicePixelRatio from the active tab, serialize it, pass it alongside the image payload, and manually do the scaling math inside the Offscreen Document. The complexity starts to compound.

What if I broke the golden rule and did the work on the main thread instead?

Working On The Main Thread

Some developers will argue that UI tasks are the only things that should run on the main thread, but I don’t fully agree with that. Personally, I believe that user explicitly-invoked actions that need immediate results can sometimes get a solid pass to run on the main thread, provided the work is incredibly fast (e.g., 1s).

That’s what I did: scrap out the Offscreen Document and reengineer the logic. Instead of:

Background → [serialize] → Offscreen Document → [serialize] → Background → Content Script

…I decided to run the whole image processing in the active tab:

The background Service Worker captures the screen and gets the Base64 string (same as before).
The background sends the payload directly to the content script in the active tab using chrome.scripting.executeScript().
The content script (running on the main thread) receives the payload, draws it to a canvas, performs the crop using the correct DPR value, and copies the result to the clipboard.

// Background Script
const screenshotUrl = await chrome.tabs.captureVisibleTab(undefined, { format: "png" });

// Inject the processing function into the active tab as a content script
await chrome.scripting.executeScript({
  target: { tabId: activeTab.id },
  func: processAndCopyImage,
  args: [{ base64Image: screenshotUrl, cropData: userSelection }]
});

This approach completely clears out multiple context hops and round trips that JSON serialization requires. The only cross-context transfer involves sending the data URL from the background to the content script.

The Retina DPI issue essentially solved itself, as the content script runs directly inside the real, active browser tab because it knows the monitor’s real devicePixelRatio.

But there’s an elephant in the room that you may have noticed.

Sure, the image is now processed on the main thread, and the background manipulates the canvas in the active tab. I could technically be blocking the main thread. That’s where I amended the “no blocking the main thread” rule to “no blocking the main thread for too long.” In this specific case, at least, blocking the main thread for a task the user requests for approximately one second is justifiable. It works conversely as well: maybe don’t isolate processes if the data transfer cost is greater than the processing cost.

Conclusion: When To Isolate And When Not To

I’ve boiled it down to a mental model that depends on whether the task is:

1. Compute-Heavy Tasks (CPU-Bound)

These are tasks where the primary cost is computation and not the size of the data itself. These are tasks where most of the time is spent on doing calculations or heavy transformations, e.g., image compression, audio profiling, physics simulation, etc.

The transfer cost for these tasks is minuscule compared to the actual work.

2. Data-Heavy Tasks (Data-Bound) #

These tasks are the exact opposite. These tasks are only expensive because of the size. The processing time is almost insignificant, but the data is expensive to transport, e.g., image cropping, filtering an array, shallow copy, etc.

In my specific case, offloading the task to the background falls mostly into negative-sum efficiency. If we are talking about moving megabytes of data to perform a 50ms operation, there is no benefit to offloading it to the background.

Perhaps we can think of it like this:

Total Time = Serialization Cost
  + Transit
  + Background Processing Time
  + Deserialization Cost

Looking at this, if the “background processing time” is the most dominant task in your operation, then isolation is the clear winner. But if serialization, plus deserialization, plus transit exceeds that cost, then there’s no need to isolate things.

And if you can’t figure out if the task is CPU-heavy or data-heavy, it certainly doesn’t hurt to measure it, for example, using performance.mark() and performance.measure() around postMessage calls to profile the transfer cost.

From Kickoff To First Concept: How To Turn Brand Strategy Into Visual Direction

noreply@blogger.com (H) — Thu, 23 Jul 2026 05:56:14 +0000

The strongest visual concepts don’t start in Figma. They start with the right questions. Explore the pre-concept phase of brand identity design, where teams research brand context, uncover hidden assumptions with stakeholders, and turn shared direction into a visual foundation before a single concept is created.

When a branding project fails, it usually happens long before the logo stage: in the strategy phase, when words like “modern,” “trustworthy,” “premium,” “friendly,” and “disruptive” are left undefined. The result is a gap between what the brand is supposed to communicate and what the designer is expected to create. This is the space I like to call the “pre-concept” phase.

At the beginning of a project, designers usually receive many inputs: a brief, a few stakeholder conversations, competitor references, maybe a moodboard or a list of adjectives. From there, they are expected to create visual concepts that feel right. But “right” is difficult to judge when the team has not agreed on what the brand is supposed to communicate in the first place.

As an example, a health tech company we worked with said they wanted to look modern, trustworthy, and disruptive. At first, “disruptive” sounded like a push toward something bold and unconventional. But as we talked, it became clear that disruption, for them, still had to feel credible inside a conservative healthcare environment. Their clients were large government medical institutions. A brand that felt too rebellious, experimental, or visually loud would not create the right kind of trust.

In other words, their version of “disruptive” looked more traditional than the word suggested.

The problem was not that the client used the wrong language. The problem was that the language was too broad to guide design decisions. Before a designer can turn strategy into a visual concept, those words need to become more specific. What kind of modern? Trustworthy in what way? Disruptive compared to whom? And how far can the brand move away from category expectations before it starts to feel wrong for its audience?

This article is about that pre-concept phase: the work that happens after the kickoff but before the first visual direction. While the broader brand identity process for digital products includes strategy, concepts, implementation, and the assets a product team needs to build consistently, this article focuses on the earlier work that makes the first concept possible: researching the brand context, uncovering hidden assumptions with stakeholders, and turning shared direction into a visual foundation. Rather, a practical bridge between what the brand needs to mean and how it might begin to look.

The first place to build that bridge is the brand workshop, where broad discovery needs to become a clearer understanding of the brand context.

A pre-concept reference board showing how brand character can move from overall look and feel to design code and early brand identity cues. The board uses publicly available visual references to discuss mood, principles, and possible graphic directions before original concept work begins

Stage 1: Research The Brand Context

A brand workshop will naturally cover the standard discovery topics: the business, its goals, the product or service, the competitive landscape, and the target audience. This article will not try to list every question a designer should ask in that workshop. For readers who want a broader starting point, we prepared a Brand Workshop Toolkit: Questions and Exercises, a FigJam framework we use in our studio to structure discovery conversations.

Here, I want to focus on a smaller set of questions that are easy to skip but extremely useful before visual work begins. These questions are less about collecting facts and more about clarifying perception. They help the team understand what the brand needs to make people believe, where it needs to feel credible, and which category assumptions it should follow or challenge.

Perception sits at the center of brand discovery because the brand is shaped in someone else’s mind.

“A brand is a person’s gut feeling about a product, service, or company.”

— Marty Neumeier, The Brand Gap

If the brand ultimately lives in someone else’s perception, the workshop has to clarify what perception the team is trying to create.

The perception questions I focus on are:

What should people believe about the company after seeing the brand for the first time?
What would make the brand feel credible in this category?
If the brand were a person in the room, how would they speak?
What do customers currently misunderstand about the company, product, or category?
Where does the brand need to fit the category, and where does it need to break from it?

These questions help reveal the assumptions behind people’s opinions, instead of simply adding more opinions to the room. The questions matter because brand attributes often sound aligned before they are actually understood. A stakeholder may say the brand should feel “premium,” and everyone may nod. But one person may mean refined and editorial. Another may mean expensive and exclusive. Another may mean clean, quiet, and minimal. The word sounds shared, but it can lead to three completely different visual systems.

For instance, in the health tech project mentioned earlier, the client described the desired brand as “disruptive.” In many categories, that might suggest something bold, loud, or unconventional. But their audience was large government medical institutions, so disruption had to be expressed through clarity, efficiency, and confidence rather than rebellion. If we had taken the word at face value, the visual direction could easily have moved too far from what their audience would trust.

In another project, a fintech team wanted the brand to feel “bold” without losing credibility. That word created useful tension. The word bold could mean bright colors, oversized typography, and a highly expressive system. But in a financial category, it also had to carry signals of security, control, and competence. The question was not whether the brand should be bold, but what kind of boldness would still feel trustworthy.

When the team can define what these attributes mean in context, the designer is no longer working from broad adjectives. They are working from a clearer design problem.

Stage 2: Reveal Hidden Assumptions With Stakeholders

Strategically selected questions can uncover part of the verbal layer, but words alone are rarely enough. To move from language into visual direction, it helps to incorporate exercises that make stakeholders think through images, associations, and relative perception.

Jake Knapp makes a similar point in GV’s Three-Hour Brand Sprint:

“The point of these exercises is to make the abstract idea of “our brand” into something concrete.”

— Jake Knapp

The following two exercises help translate what stakeholders say about the brand into material that can later inform look and feel, design principles, and concept development.

This is also where stakeholder participation becomes important. When clients only receive a strategy presentation, they can stay passive. They may agree in the meeting without noticing the assumptions they are bringing into the process. But when they have to place a competitor on a map, choose an image, or explain why a certain reference feels credible, they become active participants. Their attitudes, beliefs, and disagreements become visible before they have a chance to derail the first concept review.

I usually start by looking outward at the category, then inward at the brand itself.

Exercise 1: Competitor Perception Mapping

Before the workshop, collect screenshots of competitor brands, websites, product interfaces, social visuals, or other visible brand touchpoints. During the workshop, ask the client team to place those competitors on a simple two-axis map.

This exercise is not about deciding which competitors have “good” or “bad” design. It is about understanding how the client reads the category: what feels credible, what feels generic, what feels too conservative, what feels too experimental, and where there may be an open visual territory for the brand.

The axes should be chosen based on the tension the brand needs to solve. For example:

Traditional to progressive.
Corporate to human.
Understated to bold.
Accessible to exclusive.

A completed competitor perception map showing how stakeholders positioned category references across two axes: understated to bold and accessible to exclusive. The references are used to discuss perception, not to define final design choices.

For a health tech company that wants to feel innovative but works with conservative medical institutions, the map might use traditional to progressive and corporate to human. For a fintech brand that wants to stand out without losing trust, it might use understated to bold and accessible to exclusive.

The most useful part of this exercise is often not the final map, but the disagreement it creates. One stakeholder may read a competitor as progressive, while another sees it as generic. One may see a brand as premium, while another reads it as cold. These disagreements reveal how different people define trust, innovation, credibility, and differentiation. That is exactly the kind of ambiguity that needs to be resolved before design begins.

Exercise 2: Visual Brand Driver

After the team has discussed the category, I like to turn the conversation inward. One exercise we use for this is called Visual Brand Driver. Each stakeholder is asked to choose images for a set of unrelated categories: transport, typeface, activity, furniture, mood, object, animal, architecture, and drink.

The instruction is important: the images should not represent the person’s personal taste. They should represent the company.

A completed Visual Brand Driver exercise, where stakeholders use images and adjectives to describe how they perceive the company.

For example, if the company were a type of transport, what would it be? A quiet electric car, a high-speed train, a private jet, a bicycle, a delivery van? If it were a piece of furniture, would it be a soft lounge chair, a precise modular desk, or a heavy boardroom table?

After choosing the images, each person adds four or five adjectives to explain why they selected them. This part matters more than the image itself. The same object can mean different things to different people. A train might suggest speed, structure, reliability, mass accessibility, or a fixed route. A lounge chair might suggest comfort, calm, informality, or lack of urgency.

The exercise helps create a deeper layer of brand perception. Instead of asking people to describe the company directly, it asks them to think through metaphor and association. Patterns and contradictions become visible. One stakeholder may see the brand as refined and calm, another as energetic and experimental. One may describe the company as precise and structured, another as warm and flexible.

Those differences are not a problem. They are useful materials. They show what needs to be clarified before the visual concept phase begins.

This exercise is also helpful because it separates brand perception from aesthetic preference. A stakeholder may personally like a certain image, but if it does not describe the company, it should not be part of the exercise. That distinction is important throughout the branding process. The question is not “Do we like this?” but “Does this express the right thing about the brand?”

Stage 3: Turn Shared Direction Into A Visual Foundation

Once the workshop has revealed the main assumptions, the next client meeting can turn that shared understanding into a visual foundation. This is still not the first identity concept. It is a working layer between strategy and design, where the client can react to perception, visual principles, and early asset directions before the designer invests time in full concepts.

We usually structure this meeting around three connected layers:

Look and feel
What should the brand feel like?
Design code
How can key brand ideas become visual principles?
Branding assets
What early choices should guide typography, color, logo direction, imagery, and illustration?

Together, these layers move the conversation from perception to practical design boundaries.

Look And Feel

Look and feel boards are not collections of visuals the team likes. They are perception boards. The designer collects references based on the workshop: desired perception, category tension, competitor codes, stakeholder disagreements, and brand character.

If the brand needs to feel trustworthy, modern, and human, the board should help the team discuss what kind of trust, modernity, and humanity are appropriate. Is the brand calm and institutional, or warm and accessible? Is it progressive through precision, or through a more expressive editorial tone?

The point is to let the client respond to perception before reacting to a logo, color palette, or finished visual system.

Look And Feel Board For A Prop Tech PR Agency. The board includes third-party visual references gathered for inspiration and discussion during the design process.

Design Code

Design code makes the direction more specific by translating key brand ideas into visual principles.

For a parenting app in Germany, personalized support for your unique journey might become organic shapes, handwritten lines, and softer compositions. Parenting is messy and magical might become soft gradients, layered imagery, and playful irregularity. Research-backed support for real life might introduce doctor calls, data snapshots, infographics, and editorial layouts that make the brand feel credible.

For a PR agency working with prop tech companies, momentum in motion might become lines, arrows, ripple effects, or motion blur. Springboard might become a lift-off moment and elastic visual energy. Building blocks might become modular shapes or stacked compositions.

The team is not choosing the final graphic expression here. It is testing whether the visual metaphors make sense before concept design begins.

Design Code For A Parenting App. The board includes third-party visual references gathered for inspiration and discussion during the design process. (Large preview)

Brand Assets #

The final layer brings the conversation down to the building blocks of identity: typography, color, logo style, photography, illustration, and graphic language.

Early Brand Asset Direction for an Infrastructure AI Startup. The board includes third-party visual references gathered for inspiration and discussion during the design process.

At this stage, the team can discuss questions such as:

Should the typography feel editorial, technical, warm, precise, expressive, or restrained?
Should the color palette follow category codes or create contrast?
Should the logo be a quiet typographic mark, a flexible symbol, or a more expressive character?
Should photography feel documentary, polished, intimate, product-led, everyday, or aspirational?
Should illustration explain complex ideas, add warmth, or become a distinctive brand language?

This gives the designer boundaries without making the final identity predictable. The next step is still concept design, but the team is no longer starting from vague adjectives or private expectations.

Early Brand Asset Direction For A Parenting App. The board includes third-party visual references gathered for inspiration and discussion during the design process.

Pre-Concept Checklist

Before moving into the first concept, it helps to pause and check whether the team has enough shared direction. The checklist is not meant to make every decision in advance. It is meant to make sure the designer is not starting from vague words, hidden assumptions, or unresolved disagreements.

Before creating the first concept, check whether the team has:

A clear understanding of what the brand needs to communicate.
A defined brand character.
A shared sense of what that character means and what it does not mean.
Visual references tied to perception, not taste.
Key brand ideas translated into visual principles.
Early direction for typography, color, imagery, and graphic language.
Documented areas of agreement and disagreement.
A clear sense of which concept directions would be wrong before designing them.

This last point is especially useful. A strong pre-concept phase not only tells the designer what to explore. It also clarifies what to avoid: directions that would be too expected, too cold, too playful, too conservative, too loud, too generic, or too far from what the audience can trust.

When the team can name those boundaries, the first concept becomes easier to evaluate. The conversation shifts from “I like it” or “I do not like it” to “Does this express the brand we agreed on?”

The First Concept Should Not Be A Guess

The first concept should not feel like a guess or a surprise reveal. It should feel like the next step in a direction the team already understands.

That does not mean removing intuition, experimentation, or creative risk from the branding process. It means giving those things a sharper problem to solve. When the team has clarified the brand character, tested visual perception, translated ideas into design principles, and discussed the early building blocks of the identity, the designer can explore with more confidence.

Pre-concept work does not need to make the final identity predictable. It needs to make the conversation around it more meaningful. Instead of asking whether the work matches someone’s private expectation, the team can ask a better question: Does this visual direction express what the brand needs to become?

Meet Kirki: WordPress’s First Visual Builder With An Infinite Canvas

noreply@blogger.com (H) — Wed, 22 Jul 2026 14:45:00 +0000

We have been building websites inside boxes for years on WordPress. Let’s take a closer look at Kirki, the first freeform visual builder with an infinite canvas, and explore how it redefines the experience with cleaner performance, full design freedom, and zero plugin dependency.

For years, WordPress users have relied on traditional page builders to create websites without writing code. While these builders made web design more accessible, many still come with familiar compromises — rigid layouts, reliance on multiple third-party plugins, bloated code, and performance trade-offs that can slow down your site.

Kirki takes a different approach. Instead of building on the conventions of older page builders, it reimagines the website creation experience with a freeform infinite canvas, an integrated CMS, and a comprehensive set of built-in features. The result is a streamlined workflow that gives you greater creative freedom while producing cleaner, faster websites.

Whether you’re a designer seeking pixel-perfect control, a developer looking for cleaner output, or a business owner who simply wants to build a professional website without unnecessary complexity, Kirki aims to remove many of the limitations that have long been associated with WordPress page builders.

In this review, we’ll compare Kirki with traditional WordPress builders across the factors that matter most when choosing a website builder, including:

Pricing and overall value,
Impact on website performance,
Ease of use versus design flexibility,
Built-in features and functionality,
Theme compatibility and layout customization.

By the end, you’ll have a clear understanding of where Kirki stands and whether it’s the right choice for your next WordPress project.

A Closer Looks At Kirki

Kirki is a no-code visual website builder for WordPress, designed to bridge the gap where other page builders fall short.

(Large preview)

Unlike other page builders, Kirki is an all-in-one solution that aims to provide everything you need to build websites without any third-party dependencies, shifting from the norm in WordPress!

And the best part? It’s all included in your subscription, so you won’t be hit with surprise upgrades.

The Most Feature-Packed Free WordPress Builder

Before anything else, Kirki has a free version, and it’s genuinely powerful.

You can download Kirki for free directly from WordPress.org and start building right away. The free version is not a watered-down teaser. It’s a heavily feature-packed builder that lets you design modern websites on an infinite canvas without spending a cent.

Scale Without Limits With the Pro Plan

For those who want to unlock the full Kirki experience, the Pro plans are surprisingly affordable for the value they deliver.

Overview of Kirki’s affordable and transparent pricing plans.

The Starter plan is just $59/year for one site and includes all premium features. Compare that with Elementor Pro’s Essential plan, which starts at $60/year and still keeps several essentials behind paywalls. With Kirki, what you see is what you get, everything included from day one.

Kirki also offers a Lifetime plan for a one-time payment of $499, giving you unlimited use forever. No renewals, no upcharges, no surprises.

While most page builders upsell critical features or require multiple add-ons to function properly, Kirki keeps it simple. One platform, all features, no hidden costs. Dynamic content, pop-up builder, form builder, submission manager, the entire growing template library — all included from the start across every plan.

Explore Kirki pricing.

Website Performance Comparison

Performance directly impacts user experience, SEO, and conversion rates. So, to get a clear picture of how different page builders impact performance, we put Kirki and Elementor to the test under identical conditions to see how each builder stacks up.

We installed both on a clean WordPress setup using the default Twenty Twenty-Five theme to ensure a fair comparison. Then, we created identical layouts using comparable design elements and ran Lighthouse performance audits to measure load time, responsiveness, and Core Web Vitals.

Test Conditions:

Clean WordPress installation,
Same theme: Twenty Twenty-Five,
Same layout structure and design elements,
Lighthouse is used for performance scoring.

Sample Layout:

Sample website layout used for benchmarking performance tests.

Kirki’s Performance:

Performance results showing Kirki’s fast loading times and metrics. (Large preview)

Elementor’s Performance:

Performance results illustrating Elementor’s load times and metrics.

Kirki’s Code Output:

Clean and minimal code output generated by Kirki for optimized websites. (Large preview)

Elementor’s Code Output:

Nested and bulky code output produced by Elementor, affecting performance.

The difference was immediately clear. Kirki generated a much cleaner DOM with significantly fewer <div>s and no unnecessary wrappers, resulting in faster load times and higher scores across all boards.

Elementor, on the other hand, added heavily nested markup and extra scripts, even on this simple layout, which dragged down its performance.

If clean code, fast loading, and technical efficiency are priorities for you, Kirki clearly comes out ahead.

Exploring The Features

Now that we’ve seen how Kirki outperforms the competition and does so at a highly competitive price, let’s dive into the features to see what makes it such a powerful all-in-one builder.

Freeform Infinite Canvas For True Design Freedom

What makes Kirki different from the existing page builders is its infinite canvas.

With Kirki, you finally get the layout flexibility modern design demands, and no longer need to place elements into rigid structures.

Kirki’s flexible freeform canvas enables pixel-perfect design freedom.

Design on an infinite canvas where you can pan freely, zoom in and out, place elements exactly where you want, overlap sections, layer backgrounds, and build complex interactions, all visually.

Every element’s layout behavior is editable on canvas, giving you pixel-level control without touching code.

The editor supports both light and dark modes for a more comfortable, focused workspace.

If you’ve used Figma or Webflow, you’ll feel instantly at home. If you haven’t, this is the most natural way to design websites you’ve ever tried.

Concurrent Editing Across All Responsive Views #

With Kirki’s infinite canvas, all your responsive views, Desktop, Tablet, Landscape, and Mobile, are visible side by side simultaneously. You don’t switch modes. You work across all of them at once, in real time, on the same canvas.

This means you can spot a layout issue on mobile while designing the desktop version, fix it instantly, and move on without ever breaking your flow. No back and forth.

Concurrent editing across all responsive views on an infinite canvas. (Large preview)

And because Kirki uses a cascading system, changes made at larger breakpoints automatically flow down to smaller ones, so you’re never starting from scratch at every screen size. You only step in where you need to, making adjustments where the design requires it and letting the rest handle itself.

Instant Figma to Kirki Handoff

Talking about Figma, if you have a design ready in Figma, you can instantly import it into Kirki to create a functional website with no need to rebuild from scratch.

Seamless import of Figma designs directly into Kirki for fast development.

Your imported design comes in fully responsive by default, adapting to all screen sizes, including any custom breakpoints you define.

And it supports unlimited breakpoints, too. You can define layout behavior exactly how you want it, and styles will cascade intelligently across smaller screens.

No Third-Party Plugins Needed for Dynamic Content #

In traditional WordPress, handling dynamic content means installing the ACF or other third-party plugins.

Kirki’s native dynamic content management without third-party plugins.

But with Kirki, all of that is natively integrated. It comes with a powerful Dynamic Content Manager that lets you:

Create custom content types and fields.
Use reference and multi-reference relationships.
Build dynamic templates visually.
Add dynamic SEO to template pages.
Apply advanced filtering to Collection elements.

All without writing a single line of code or relying on external plugins.

Reusable Styling With Class-Based Editing

Kirki also has an efficient way to manage design at scale without repetitive work.

Efficient class-based styling system for reusable and scalable designs. (Large preview)

It uses a class-based styling system that brings structure and scalability to your design process. When you style an element, those styles are automatically saved as reusable CSS classes.

Here’s what that means for you:

You can create global classes for common components like buttons, cards, or headings.
Reuse those styles across pages and projects with consistency.
Update a class once, and every instance updates instantly.
You can also create subclasses to make slight variations, like secondary buttons, while still inheriting styles from the parent.

CSS Variables for Global Styling

Kirki takes styling even further with Global Variables, allowing you to define design tokens like colors, fonts, spacing, and sizing that can be reused across your entire site.

Global CSS variables powering consistent and easy-to-update site styling.

You can pair these global variables with your class-based structure to:

Maintain visual consistency.
Update values globally with a single change.
Easily manage themes like switching between light and dark modes with one click.

And while Kirki offers a fully visual experience, it doesn’t limit advanced users. You can write custom CSS for any class or element, and even inject JavaScript at the page or element level when needed.

Build Complex Interactions and Animations Visually

When it comes to modern animations and interactive design, Kirki leaves traditional WordPress page builders far behind.

Its fully visual interaction builder lets you create dynamic, immersive experiences.

Visual interaction builder allowing advanced animations without coding. (Large preview)

You can build scroll-based animations, hover and click effects, interactive sections that respond across devices, and control visibility, motion, and behavior all within a visual interface.

For advanced users, Kirki includes a timeline-based editor where you can:

Create multi-step animations.
Fine-tune transitions with precise timing, easing, delays, and sequencing.

Even text animations get special attention.

You can animate text by character, word, or full element. Choose custom triggers (scroll, hover, load, etc.) and select from various transition styles or create your own.

Kirki no-code website builder truly helps you move past generic and create unique animations and complex interactions.

Seamless Integration Management with Kirki Apps

Kirki takes the hassle out of connecting third-party tools with its intuitive Kirki Apps system. You can install and manage essential integrations such as analytics, CRMs, email marketing platforms, support widgets, and more, all from within the Kirki editor itself.

Centralized integrations management with Kirki Apps. (Large preview)

This centralized approach means you never have to leave your workspace. The clean, user-friendly interface guides you through the connection process visually, making setup fast and straightforward even if you’re not a technical expert.

First True Multi-user Co-editing & Commenting Experience in WordPress

Kirki brings the first real multi-user co-editing experience to WordPress. Multiple team members can work on the same page, at the same time, seeing each other’s changes unfold live on the canvas.

First True Multi-user Co-editing Experience in a WordPress Builder.

You see your teammates’ cursors moving in real time. You watch edits happen as they happen. Every change is color-coded and attributed, so the entire team stays oriented without ever having to ask.

Your team can also leave comments directly on the canvas, pinned exactly where the change needs to happen. For agencies, freelancers working with clients, and in-house teams juggling multiple contributors, this makes a huge of a difference.

Built-in Quality Control

Before you publish your site, Kirki helps ensure your site is technically sound with its built-in Page Audit tool.

Page Audit tool ensuring SEO, accessibility, and technical quality before publishing. (Large preview)

It automatically scans your layout for:

Missing alt text on images,
Broken links,
Unassigned or duplicate classes,
Accessibility issues,
And more.

So you’re not just building beautiful pages — you’re shipping fast, accessible, SEO-ready websites with confidence.

Theme & Layout Options

Kirki has a growing library of high-quality templates and modular layout options, so you’re never out of options.

Extensive library of templates, pre-designed pages, and modular sections.

Template Kits: Full Website Packs

Kirki’s Template Kits include complete multi-page website designs for every industry. Pick a template, update the content, and you’re ready to launch.

New template kits are added regularly, so you’re always equipped with the latest design trends. And the best part? At no additional cost. You get access to the finest designs without ever paying extra.

Pre-Designed Pages

Need just a landing page or a pricing page? Kirki also offers standalone pre-designed pages you can drop into your project and customize instantly.

Pre-Made Sections #

Prefer to build from scratch but don’t want to start with a blank canvas? It also has ready-made sections like hero banners, testimonials, pricing blocks, and FAQs. You can visually assemble your layout in minutes using these.

How Easy Is Kirki To Use?

Kirki has come a long way in terms of accessibility.

The interface has been refined, the workflow is more intuitive, and a growing library of pre-made blocks, sections, pages, and full templates means you’re rarely starting from a blank canvas unless you want to.

That said, if you want something dead simple just to build a basic five-page site fast, there are lighter options out there like Elementor. But they come at the cost of power, performance, design control, and long-term flexibility.

Kirki is built for people who care about what they’re building. If you want pixel-level control, clean code output, truly responsive layouts, dynamic content, advanced interactions, and a site that scales without breaking, Kirki delivers all of that, and it’s more accessible than ever to get there.

To help you get up to speed quickly, Kirki includes:

A refined, intuitive interface that’s easier to navigate than ever;
An extensive and growing library of templates, pages, pre-built sections, UI components, and wireframes to kickstart any project instantly;
Guided onboarding to walk you through the essentials;
An AI generator that can scaffold entire pages and layouts in seconds.

The bottom line is that Kirki rewards the time you put into learning it. And with everything that’s been added recently, that time is shorter than ever.

What Users Are Saying

For many users, Kirki is more than just a builder. It’s the all-in-one tool WordPress has been waiting for. They are calling it the future of WordPress, a truly great alternative to tools like Framer and Webflow.

User testimonials praising Kirki’s power, performance, and design freedom.

Why Kirki Outshines Traditional Website Builders

Building a professional WordPress website shouldn’t mean compromising on speed, flexibility, or performance. Kirki is designed to give designers, developers, and businesses a modern visual building experience that goes beyond the limitations of traditional page builders.

Modern Freeform Visual Builder

Design without being restricted by rigid rows or predefined layouts. Kirki’s intuitive freeform canvas lets you place, arrange, and customize elements exactly where you want them, giving you complete creative freedom.

Real-Time Responsive Editing

Perfect your website for every screen size with side-by-side responsive editing. Instantly preview and fine-tune your desktop, tablet, and mobile layouts simultaneously, eliminating the guesswork from responsive design.

Everything You Need in One Builder

Forget installing multiple add-ons and third-party extensions. Kirki includes the essential tools, widgets, and features you need in a single, integrated platform, reducing complexity while improving reliability.

Performance-Optimized Code Output

Great websites don’t just look good—they load fast. Kirki generates clean, lightweight, and optimized code that helps improve page speed, user experience, and search engine performance.

Seamless Figma to WordPress Workflow

Transform your Figma designs into fully functional WordPress pages with minimal effort. Reduce development time and maintain design accuracy from concept to launch.

Advanced Design Capabilities Built In

Create dynamic websites with data-driven content, engaging animations, sophisticated interactions, and global styling controls that keep your branding consistent across every page.

A Powerful Free Version To Get Your Site Ready

Start building immediately with a feature-rich free version that includes everything you need to create a polished, professional website before deciding to upgrade.

Overall Verdict: Is Kirki Really Better Than Alternatives?

After putting Kirki through its paces, the answer is a clear yes. Kirki not only matches traditional WordPress page builders where it counts, but it surpasses them in nearly every critical area.

From its cleaner, faster code output and outstanding performance to its unparalleled design freedom and powerful built-in features, Kirki solves many of the pain points that users have accepted for years.

Its all-in-one approach eliminates the need for multiple plugins, saving time, money, and technical headaches. If you’re serious about building high-quality, scalable, and visually stunning websites, Kirki isn’t just an alternative; it’s the future of WordPress site building.

Ready to experience the difference yourself? Try Kirki today and start building faster, cleaner, and smarter.

Designing For Distressed Users: Why Mental Health Apps Shouldn’t Follow Every UI Fashion

noreply@blogger.com (H) — Wed, 22 Jul 2026 05:34:04 +0000

Many UI trends are designed to capture attention and signal innovation, but those goals often conflict with the needs of mental health apps: reducing cognitive strain, fostering trust, and providing a sense of refuge. Here it introduces an evaluation framework that helps designers assess whether trendy visual and interaction patterns support or undermine the unique goals of mental health experiences.

Mental health applications keep facing a continuing, measurable crisis: many people stop using them quickly. The data is stark: almost 95% of users who open the app on day 1 abandon the app by day 30, with a median 30-day retention of only 3.3%. Even the recognised mental health giants lose around 50% of their users within the first ten days. This severe engagement loss and retention collapse are why effective interface design must be a clinical and operational priority. Good design is not merely aesthetic; it is a fundamental tool for user retention.

While many factors drive this abandonment, research suggests that mental health apps have tended to prioritise visual appeal at the expense of what actually sustains users. In a space defined by vulnerability and cognitive strain, chasing visual fashion risks adding effort when users have the least to spare — quietly trading away the utility and trust the app depends on. Users don’t open mental health apps out of curiosity, but from need — often while stressed, anxious, overwhelmed, or exhausted. In these states, an unconventional icon, a confusing gesture, or a flashy animation instead of a delightful surprise becomes an extra cognitive overload. Moreover, it becomes a reason to disengage.

In those moments, visual experimentation from a mild distraction can turn into a friction that undermines the very help the app is meant to deliver. A solution must be a visual interface that is simple in usage and understanding from the first moment.

Crucially, improving engagement depends less on which UI trends you follow than on a single test applied to each one of them: does a trend lower the cost of using the app when the user can least afford it?
“

The High Cost Of Trend-driven Design In Mental Health

Before we look into the specific problems, we must recognise a core tension: many UI trends are optimised for goals that mental health apps don’t share.

Trend design is often about capturing attention and signaling innovation. Mental health design, in contrast, must be about offering refuge, reducing strain, and building trust.

(Large preview)

Pursuing the former directly overrides the latter. It’s not a surface-level error of colour or font; it’s a foundational conflict of purpose. This tension surfaces across five fronts, each a place where adopting a trend on novelty alone can cost more engagement than it seeks to create.

The proposed principles are not based on a single A/B test or one isolated study. They are built from published research on mental health app engagement, cognitive load, accessibility, and emotional response in mHealth, set against competitive product audits and app-store evidence, and pressure-tested against my own quantitative and qualitative product work. That last source I treat as an illustration, understanding the limits of personal experience. In this context, validation is less about proving that one interface pattern universally works and more about asking whether a design reduces effort, preserves agency, avoids emotional mismatch, and remains usable when the user is already under strain.

“Distressed user” here refers not to a diagnosis, but to a reduced-capacity state in which everyday tasks, choices, and self-care can require more effort than usual.

A note on the examples: This isn’t a ranking of apps. Every app has its own positioning, target audience, constraints, and business pressures that may not be visible from outside, and a pattern that strains a user in distress may be exactly right for that product’s actual goal. I’m reading individual, visible design decisions for one question only: how they might affect someone arriving in a low-capacity state.

1. Cognitive Friction: When Design Becomes A Barrier To Healing

The primary goal of any mental health tool is to reduce, not increase, cognitive load. Yet, many trendy interfaces achieve the opposite. Neo-brutalist layouts with stark contrasts demand visual parsing. Hidden navigation menus that rely on non-standard swipes turn simple tasks into puzzles. Abstract, unlabeled icons force users to guess rather than recognise. Each of these patterns adds friction — seconds of hesitation, a moment of confusion — and for a user whose mental energy is already low, those costs start to accumulate.

Abstract controls can add interpretation effort, even in otherwise polished wellbeing interfaces.

This friction is most damaging during acute need. Research suggests that when a user is in a state of high anxiety or depression, even typing or making simple choices can feel overwhelming. When an interface demands high cognitive effort at the moment support is needed, it doesn’t just make that session harder — it gives an overwhelmed user a reason to close the app, and a reason not to reopen it. Each point of confusion can become a place where a user may quit for good.

Other findings show that apps with simple interfaces reduce the time and effort required to engage, directly improving retention. Conversely, a complex, trend-driven UI increases that time, creating an obstacle course that undermines the very healthy habit formation the app is meant to support.

This does not mean that every mental health product must be visually plain or minimal. The issue is whether the interface meets the user’s current capacity.

A panic-support tool, for example, works best when it offers a small number of obvious actions, rather than asking the user to browse. However, if a calming action meant for a moment of panic instead surfaces an upgrade screen, the product fails the user at precisely the point where failing matters most. Monetization is not the issue by itself; the issue is whether it appears at a point where the user expects immediate support.

A clear panic entry point lowers cognitive load; surprise paywalls inside support actions can reintroduce friction.

Nonori shows the same principle in a more reflective context. The app does not present the user with a large content library or a complex dashboard at the start. Instead, it leads them through a simple, linear sequence of small actions. The value of this pattern is that it reduces the effort needed to begin. When a user is tired, anxious, or mentally overloaded, knowing exactly what to do next can lower the barrier to returning.

A linear flow reduces the need to decide what to do next.

At the other end of the spectrum, comprehensive tracking apps show a different trade-off. Bearable, for example, is genuinely powerful: it consolidates almost everything a person tracks — mood, symptoms, sleep, medication, habits, reports, correlations — into one place. For users managing chronic conditions or preparing for medical appointments, this can be genuinely useful. But the same comprehensiveness can become a burden for an exhausted user. Dense dashboards and multi-step check-ins require executive capacity — the very resource that anxiety, depression, burnout, or brain fog often reduce.

Comprehensive tracking can be valuable, but dense check-ins require executive capacity.

A similar tension appears in anxiety apps with strong support content but busy entry points. A product may contain useful features yet still make the first screen feel noisy with too many cards, locked items, playful characters, or upgrade prompts. This is not evidence that the product is bad. It shows how the same interface can feel very different depending on the user’s state: clear enough during exploration, but too demanding during distress.

In low-capacity states, visually rich home screens can make the path to support harder to find.

This insight shaped a guiding principle for our work: every interaction point must meet users at their current level of capacity, removing mechanical and cognitive barriers rather than adding to them. This principle guided our integration of low-friction, state-aware interactions in apps like Bear Room, a stress and anxiety reduction app, and Teeni, an emotional-wellbeing app for parents of teens.

In Bear Room, we already had a fast mood-based flow built around four emotion cards. At the same time, our product research supported a second need: users also wanted more personalised support. We avoided making this a long selection flow or a typing-only route because both can still create friction for people under stress or anxiety. Instead, we made voice a primary, prominent path, always alongside a text alternative. A central microphone button allows users to share what’s on their mind. The app then uses AI to analyse the input and provide a tailored set of coping practices.

Rather than picking a single entry model, we kept two paths because they served different states. That matched what we saw in later analytics and user conversations: quick emotional selection worked better when users wanted speed, while open voice or text input worked better when they wanted personalisation and to feel more heard. This was more a pattern we noticed, without having the exact measured results.

Voice is used as a low-friction alternative to typing across different tasks in Bear Room. (Large preview)

Similarly, in Teeni, we directly addressed the cognitive friction of parenting stress by introducing a “Quick Relief” button. This creates an empathy-friendly flow for parents experiencing anger or frustration. The button initiates a dedicated “Hot Flow,” allowing them to first vent and relieve their immediate negative emotions through voice input. Only after this emotional release does the app gently guide them into the more reflective “Cold Flow” for the rest of the app’s resources. This sequential, state-sensitive design acknowledges that a user in peak distress cannot navigate a complex app; they need a direct, simple, and validating first step.

Teeni’s Quick Relief flow helps parents regulate before reflection.

These solutions directly tackle cognitive friction by meeting users at their level of capacity, resisting trends that add visual or interaction complexity. Voice input and single-action buttons remove the mechanical and cognitive burden of navigation and typing. The result is an interface that feels reliably non-judgmental and genuinely helpful when users are least equipped to navigate complexity.

2. Emotional Mismatch: The Trust Erosion Of Misaligned Design Tone

A user’s emotional state is the context in which a mental health app operates. This is why its visual language must be empathetic and considerate. Research investigating how colour and aesthetics influence mood in mHealth apps suggests a critical insight: users in distress show a strong preference for subtlety. They long for dark palettes, sleek and sophisticated looks, and clean, uncluttered aesthetics, explicitly noting that cheerful, bright colours, while seemingly appropriate, can create a jarring, even physically uncomfortable conflict with their current mood.

Emotional alignment is the fit between the product’s promise, visual tone, and the user’s likely emotional state.

This does not mean that every mental health or wellbeing app should look dark, quiet, or clinically restrained. The category is broad: it includes self-care, anxiety support, habit change, addiction recovery, trauma tools, therapy-adjacent products, and apps for more severe mental health contexts. A playful visual style may be appropriate for one product and a poor fit for another. What matters is not whether the interface is bright or muted, but whether its emotional tone fits the product’s purpose and the likely state in which users arrive.

Emotional mismatch can also appear in mechanics, not only in aesthetics. In Calmer, an anxiety and panic relief app, the interface itself appeared relatively clean and relaxed. Yet some of its engagement and monetisation mechanics sit in a different register from that relaxed: a discount wheel, or confetti celebrating a logged low mood. For a user who just recorded a hard moment, that shift — from quiet support to upsell or celebration — can land as a mismatch, whatever its intent.

For Bear Room, we prototyped a “cosy room” design informed by direct feedback from our users, which echoed the study’s conclusions. Several users in our research described the apps they had tried for similar needs as “too bright, too happy, and too overwhelming”. Users longed for a digital safe space. This was part of what pointed us toward a quieter palette in the final design: muted, earthy tones — neutral hues like soft greens and taupes — set against darker, calming backgrounds. For this product — a refuge for users arriving overwhelmed — that meant a middle ground: a space that feels safe without being gloomy. The interface avoided any bright alerts or sudden animations, making calmness the core feature.

Bear Room’s muted palette was designed to create a grounded, safe, and emotionally low-friction atmosphere.

This case underscores a critical principle: an overly cheerful, bold, or trend-forward interface can feel dismissive to someone in distress, creating a conflict that erodes trust. As Bear Room shows, trust is built when the interface respectfully aligns with the user’s emotional reality, offering solace through subtlety (which creates an overall feeling of a “welcoming and safe atmosphere”), not a solution through saturation.

3. The Inconsistency Penalty: Why Novelty Undermines Routine

Mental health often relies on routine and predictability. Yet many contemporary UI trends thrive on novelty and disruption, intentionally reimagining fundamental navigation. When an app introduces a novel interaction pattern, such as a unique swipe or a non-standard button behavior, it asks the user to learn something before they can act, forcing them into cognitive effort they can’t afford.

This does not mean that mental health apps must be plain, rigid, or generic. A product can have its own character, playfulness, and sense of identity. The question is whether that identity remains understandable and predictable when the user returns in a low-capacity state. A gamified self-care app like Finch may work well when the user arrives ready to explore, play, and build a routine. But open it after a hard day just to mark one task done, and the can’t-skip celebration screens that delight an engaged user become one more layer to get through before they reach what they came for.

Playful identity can support routine, but repeated non-skippable moments may interrupt users who only want to complete a simple task.

A similar tension appears in large meditation and wellbeing platforms. Apps such as Headspace and Calm offer extensive libraries of different content. This breadth can be valuable during exploration. But in moments of stress, the product question becomes sharper: can the user return and immediately find the exact support they need, or do they have to search, filter, and relearn the structure?

Large content libraries can be valuable during exploration, but harder to navigate during distress.

Someone experiencing anxiety or executive dysfunction needs to use the tool in a straightforward navigation manner, not an interface they have to learn each time anew.

PTSD Coach, a public-health-oriented trauma-support app designed to help users learn about and manage symptoms after trauma, offers a useful positive example. Its interface is not trying to be fashion-forward. Its strength lies in a stable information architecture: users can learn, track symptoms, manage symptoms, and get support through clearly separated areas. For a user returning during distress, this predictability matters more than novelty.

Stable IA supports return use: learn, track, manage symptoms, get support.

CALMzone offers another useful example. Some of its breathing animations differ from standard visual patterns, but they remain tied to the exercise itself: the animation shows what to do, when to inhale, and when to hold. The guided audio screen also explicitly invites the user to put the phone down and listen. This is a rare and valuable form of interaction design: the product’s success is not more screen time, but reduced effort and regulation.

Novel interaction can work when it directly supports the exercise rather than distracting from it.

These insights guided our approach in applications like Bear Room, where navigation reliability was treated as a therapeutic feature. We intentionally crafted an experience of an empathetic guided flow.

Recognising that users would likely approach in states of overwhelm, we structured the interface as a clear, unwavering path, with a visible “Start” sign. Key emotional support tools here are represented as the room’s objects — symbols of daily life, unmistakably recognised by all. They are visually highlighted by design so that the user won’t get lost in the elements, can easily access the needed tool, and can remember their way around the digital space upon the next return to the app.

Navigation reliability as a guided flow: familiar objects, visible entry points, and a repeatable path to support.

Trend-driven interfaces sacrifice this navigational certainty for novelty. Each unconventional choice in mHealth apps, when core functions are buried behind experimental interactions or placed in unexpected locations, leads to a cumulative effect of fatigue instead of innovation. Users are not in a place to explore. They abandon the entire practice of seeking digital support when every interaction feels like solving a new puzzle. This does not restrict experimentation; it simply means that animations, micro-interactions, AI, or playful mechanics must serve the user’s state rather than interrupt it.

4. The Silent Exclusion: How Trends Compromise Accessibility

Many popular UI trends can be exclusionary when applied without adaptation. The minimalist trend of low-contrast text fails users with visual impairments. Gesture-only navigation marginalises those with motor difficulties. Visually dense, animated interfaces can overwhelm users with cognitive or attentional conditions. In mental health, the population needing support disproportionately includes individuals with these accessibility needs.

Low contrast, small text, and dense layouts can make support harder to access for users with visual, cognitive, or attentional needs.

Choosing a trending aesthetic over an accessible one is therefore an active decision to limit the app’s reach and efficacy. It ensures that those who might benefit most cannot use the tool effectively. Accessibility isn’t a layer you add at the end; it’s a constraint you design within, with most of it codified in Web Content Accessibility Guidelines 2.2. Body text needs 4.5:1 contrast against its background, large text and interface elements 3:1 — exactly what low-contrast minimalism fails. Interactive targets need a floor of 24×24 px (more for unsteady hands). Every gesture needs a visible button fallback, or you risk excluding anyone who can’t perform the swipe.

5. The Coercion Paradox: When “Engagement” Becomes “Pressure”

A final, and often overlooked, consequence of trend-following is the adoption of engagement mechanics designed for entertainment, educational, or productivity apps. Features like streaks, aggressive notifications, and gamified reward systems are engineered to maximise screen time and create dependency. Although they have long been considered effective tools for increasing retention, in a mental health context, this approach can easily be misguided. What presents as “motivation” can quickly transform into a source of performance pressure and guilt. For a user managing depression, a broken streak or a missed daily goal can exacerbate the very feelings the app aims to alleviate.

Streaks can motivate some users, but missed days should not be framed as failure in non-linear recovery contexts.

These mechanics are not inherently unethical. In routine-building products, they can help some users. The risk appears when they are transferred into mental health contexts without adapting for shame, low energy, relapse, and non-linear recovery. A streak, for example, is not just a retention mechanic when the user is emotionally vulnerable. It can become a visible record of whether they have “kept up” with their well-being.

In the apps I reviewed, this tension appeared through familiar persuasion patterns: streaks, streak freezes, commitment copy, urgency-based notifications, “don’t miss this offer” prompts, and success-framed buttons such as “Yes, I want to succeed.” In self-care or wellbeing products, these details can make the app feel less like a supportive tool and more like another system the user has to satisfy.

(Large preview)

Designers still need return triggers. A mental health app has little value if users install it once and forget it exists. But return mechanics must be adapted to the emotional context. In Bear Room, for example, this philosophy is embodied in short, forgiving three-day streaks: the streak does not reset when a user misses a day, and every third day brings a small benefit. The goal is not to punish absence, but to gently support return.

The same principle applies to lighter interactions. Bear Room includes a simple, optional bubble-popping game. Its purpose, however, is not to hook the user but to offer a brief, calming interlude. It is deliberately finite, providing a small mood lift and gently signposting other resources within the app. The value is in the momentary relief, not the extended session.

This commitment to supportive, non-coercive design extends to foundational app architecture:

Respectful and User-Tailored Interaction Models
The Pillow, a visual interface in the app, acts as a neutral, accepting space. Users can select a feeling or record a voice note, and the app responds with an AI-curated set of practices (28). It offers support without judgment, commentary, or pressure to “achieve” a certain state. Our app prioritises mood-aware algorithms to dynamically order activities. Breathing exercises or grounding techniques are surfaced based on the user’s reported emotional state, creating personal resonance without the need for an overwhelming content library.
Feedback as a Reciprocal Exchange
We approach feedback not as a data grab via constant emails but as a respectful dialogue. An unobtrusive object allows users to contribute at a natural pause point, and their input is acknowledged with a small reward. This frames their participation as a valued gift, not a demanded obligation.

In mental health technology, sustainable retention is earned not by capturing attention, but by becoming a consistently respectful and helpful presence in a user’s life.
“

The mHealth apps design invites finding a challenging balance between boosting their use without being too demanding.

The Scale Of The Stakes

This is not a niche concern affecting a fringe audience. The World Health Organization (WHO) estimates that about one billion people globally live with a mental disorder, with depression alone affecting nearly 5% of adults. Critically, the overall number is rising — in the last decade, depression and anxiety cases have increased by 25%. This vast and vulnerable population cannot afford for its tools to fail due to poor design. While UI trends aren’t inherently problematic, their application within wellbeing products demands a radically contextual approach.

Even a five-minute decompression tool between meetings has an emotional context, and a style chosen for its look — glassmorphism, a certain flavour of ultra-minimalism — can miss it, however sophisticated the audience. The point isn’t that these styles are wrong; it’s that the look has to answer to the moment. Soft biomorphic shapes or fluid transitions can genuinely help when they directly serve the goal of calm — and the same elements become noise when they’re there to impress.

What carries the highest risk is lifting a visually striking “Dribbble shot” and applying it without deep adaptation: it solves for the designer’s portfolio, not the user’s need.

A Practical Framework For Evaluation

The five fronts outlined above are not just a diagnostic lens; they are the foundation of an evaluation framework for anyone designing in the mental health space. Before incorporating any trendy visual or interaction pattern, it is worth running it through each of them in sequence:

(Large preview)

Cognitive load
Does this reduce the effort required for someone who is overwhelmed, or does it add another layer of complexity to an already strained experience?
Emotional alignment
Does this support a wide spectrum of emotional states, including distress and exhaustion, or does it clash with the context in which users are most likely to arrive?
Navigational reliability
Does this build trust through predictability, allowing users to return and find their way without relearning, or does it prioritise novelty at the cost of consistency?
Accessibility
Does this uphold or enhance accessibility for diverse sensory and cognitive abilities, or does it quietly exclude the users who may need support the most?
Engagement integrity
Does this invite use in a way that is supportive and non-coercive, or does it borrow mechanics from entertainment products that may create pressure rather than relief?

A design that passes all five holds together as something more than usable: it becomes a tool that users can trust enough to return to in moments of genuine need.

Trends can be inspiring. They can win awards and generate buzz. But in mental health, sometimes the best design is the one that helps users feel understood — a quiet helper they trust enough to return to in moments of stress and vulnerability. It doesn’t steal the spotlight, but focuses on the user’s emotions. In the end, the ultimate goal is not for the interface to be seen — but for the support to be felt.

No, People Don’t Want More AI In Their Life

noreply@blogger.com (H) — Tue, 21 Jul 2026 14:36:55 +0000

Many companies assume everyone craves new AI features. But the reality is that most people don’t want more AI — at least not in the way most AI leaders envision it.

Many companies silently assume that everybody wants more AI in their lives. That people are craving new AI features, new AI products, new AI workflows — that would all magically replace all existing outdated practices and broken ways of working.

But in reality, it seems like people don’t want more AI at all — at least not in the way most AI leaders envision it. Unsurprisingly, many AI features have low adoption and retention — at a very high cost of delivery, and a high risk of reputation damage.

The AI People Don’t Need

It’s remarkably difficult to make a strong argument with senior leadership, but AI is not a value proposition. New AI features don’t magically make for happy or excited customers. Because AI features are often bolt-ons and separate tools for employees to use, they typically take people out of their regular way of working.

AI is pretty good at amplifying shortcuts and shortcomings in organizations — from data quality to decision making. It can’t magically fix years of accumulated quick patches, technical debt, broken culture and internal politics. If anything, they become more visible with AI as inconsistencies or conflicting priorities and get handed directly to users, who are then left to make sense of the mess themselves.

Because in most organizations, work typically requires hopping on and off between plenty of disconnected and fragmented systems, with a new AI tool, they now have yet another system that they also need to hop on and off. Often it produces more work, and typically it’s not particularly rewarding work either.

On top of that, people are very much aware of the cost of finding and fixing AI hallucinations. Asking AI to generate a response might feel easier than writing from scratch, but it has a cost:

Skim through the entire AI output,
Spot key points to focus attention on,
Review/verify key points, one-by-one,
Check rationale for what follows next,
Articulate corrections + regenerate,
Review the response (a number of times).

AI goes in Key Activities and Key Resources — not in Value Propositions. Image by David Bland.

For many people, AI isn’t something they can proactively choose and explore on their own — it arrives uninvited, at someone else’s pace. On top of that, plenty of messages amplify fears and worries about AI replacing work — so it’s hardly surprising that the perception of AI isn’t excitement. It’s resistance to change and deep anxiety about one’s place in a world that seems to be changing without them.

AI Productivity Study / US: AI doesn’t reduce work — it intensifies it. Via Mike Rosenberg, NBC News, HBR, WSJ, Activtrak.

At best, AI features might be silently accepted or nodded away. At worst, AI raises concerns, doubts, caution — and calls for a healthy dose of skepticism. And sometimes it’s perceived as a threat or liability — because unlike other features, AI is neither predictable nor reliable.

People don’t dream of AI art museums or AI fridges or AI hotel reception or AI-narrated children’s books. They don’t want their children to have romantic AI partners. Most people don’t want to actively manage (and clean up after) a swarm of AI agents roaming in their bank accounts and acting on their behalf in the real world. And most notably, people don’t really want a magical box to speak to or type into all the time.

The AI People Actually Need

I’m always puzzled by the comparison of AI features with how unreliable humans are. But people don’t compare software with other people. They compare features with features — and if one feature in one product is unreliable, while a similar feature works flawlessly in another, they choose the latter. It’s not about AI or not AI, but rather what works consistently and reliably, and what doesn’t.

Many conversations about AI are conversations about the speed of delivery. But to many people, there is little value in increasing the speed of delivery. They want to do things well, with enough time to think and make good decisions. They also want to enjoy the time they spend working on things, rather than just ship faster. There is an enormous feeling of reward and achievement that slowly disappears, one vibe-coded change at a time.

People don’t change much. And after all these years, they (still) want features that are fast, accessible, reliable, predictable and useful — every single time. And ideally not the ones that replace their entire workflow, but that augment their way of working — and that take over the most mundane, annoying, and boring tasks that they find no pleasure in.

Jobs least and most vulnerable to AI. Sources: GovAI and Brookings Institution, via The Washington Post.

Many jobs are exposed to AI automation, but in many of them there is a rewarding, unique, creative part that requires taste, point of view, and perhaps even human intuition. And if AI automates boring parts of it, that’s an advantage for everyone. That’s also what enhances productivity and brings more joy in daily life.

When AI automates tedious and mentally exhausting tasks, its value is much easier to grasp. But for that, AI shouldn’t feel like a bolt-on. It should be deeply integrated into people’s existing workflows. It must also match existing mental models that they have developed and fine-tuned for years or decades. AI should adapt to how people think and make decisions, not the other way around.

And it doesn’t really matter if these features are branded as “AI”, “smart” or “automation”. However, they must work well for people using them. And that means that people must be aware of use cases where it actually helps them, and be inspired to find more use cases on their own.

Ironically, tools that work well there aren’t “AI-first” — they are “AI-second”. Subtle, humble, calm, ambient, taking a supportive role in the background for work that otherwise is remarkably dull and unnecessary.

I don’t want to read books written by AI. I don’t want to gaze upon paintings by AI. I don’t want AI to teach my children. I don’t want to have an AI therapist. I don’t want AI making my medical decisions. I want AI to do all the physical and mental labor that taxes me so I can read books written by humans and go to art galleries to engage with art made by humans. I want AI that makes my life easier rather than forces me to change myself.

— Bo Young Lee

Wrapping Up

Perhaps I’m missing a bigger picture, and perhaps I’m just old school — but I really do like people. Their stories, their thinking, their emotions, their enthusiasm, their laughing. AI can be remarkably helpful in many situations, but so are people. And between the two, I would favor spending time with a human — however imperfect they are — every single time.

No, people don’t need more AI in their lives — they need AI to automate all the boring stuff they have to deal with every day, so they have more time and headspace to do things that they actually love and enjoy doing. That doesn’t mean spending more time with AI — but spending more time with people they love.

Useful Resources

AI Adoption Gap: IBM 2026 Study, by MindStudio
Powered by AI Is Not a Value Proposition, by Nielsen Norman Group
AI Chatbots Discourage Error Checking, by Nielsen Norman Group
The Jobs Most Exposed to AI Automation, by The Washington Post
On AI and What We Actually Want From It, by Bo Young Lee

The real reason you think of the perfect thing to say an hour too late

noreply@blogger.com (H) — Tue, 14 Jul 2026 05:41:01 +0000

You know the feeling. You're in a meeting, someone says something, and the perfect reply, the clever line, the joke that would had everyone laughing and crying, arrives in your head at exactly the wrong time. About an hour after everyone's gone home.

For the longest time I assumed people were just born quick. Quick-witted, quick on their feet, funny in the moment without appearing to try. The rest of us, I figured, were stuck arriving late to our own best thoughts.

I was wrong about that, and I want to show you why, because being quick in the moment is a skill you can build, not a personality you're either issued at birth or you're not.

It starts somewhere that sounds completely unrelated: mastery over the foundations.

Think about a good driver. When the car in front does something sudden and stupid, the good driver dodges without thinking. They don't consult a mental checklist for where the brake is or how the steering works. All of that became automatic a long time ago, which frees up their full attention to react to whatever's happening in front of them. The nervous learner driver, still thinking about their hands and their mirrors and their feet, has no attention left over. When something unexpected happens, they freeze.

Communication works the same way. Your foundations are your voice (your pace, your volume, your melody, your pauses) and your body (your gestures, posture, eye contact, expressions). If you're standing in a meeting silently managing all of that, wondering what your hands should be doing and whether your voice sounds odd, you've got no spare attention left to actually be present. And presence is the whole game. You cannot catch the funny observation, the sharp point, the perfect moment to lighten the room, if every scrap of your focus is turned inward.

As you've likely already worked out, for most people who speak - they're not present at all. They're trapped in their own heads running a loop of worry. "I hope they like this idea. I hope I'm saying this right. I hope nobody asks me something I can't answer." When you're that deep in your own headspace, you have zero chance of picking up on what someone just said and throwing something clever back. None. Your attention is already spoken for.

Master the foundations, though, and something changes. The mechanics go quiet because they've become second nature, and suddenly you feel calm, comfortable, and clear-headed. You're finally present in the room instead of narrating your own performance from inside your skull. That presence is where quickness actually comes from.

Then there's the second part, and it's important to note, it's what almost nobody practises. The art of reviewing and reflecting.

Let's go back to school for a moment. When some kids failed a test, they'd shove it in their bag, never look at it again, and move straight on to the next topic. Other kids went back through every wrong answer to work out exactly what went wrong, so they'd never make those same mistakes again. I was very much in the first group and kept failing, and I quietly concluded I was just dumb. I wasn't dumb. I'd simply never been taught to look back and learn from what just happened. Nobody seems to teach that. Or at least, none of the teaching staff from 'back in my day' (it finally happened, I've become old) - instead, they handed me the test and said "right, on to the next thing."

So here's your one thing to try this week, and it's the habit that changes everything.

After your next meeting or important conversation, block out five or ten minutes immediately afterward, not three days later while it's stale, but right then while it's fresh. Sit down and ask yourself one question: what could I have done better in there? What did I want to say and miss? What was the joke or the point that showed up too late?

At first this will sting a little, because the great idea will still be arriving about an hour after the meeting ended, and you'll think "damn it, why didn't that come to me in the room?" Stay with it anyway. Here's what happens as the habit compounds. That gap starts to close. The idea that used to land an hour late starts landing five minutes late. Then, one day, it starts arriving while you're still in the conversation, right when you actually need it. The reflection you used to do afterward quietly moves forward in time until it's happening live. That's the whole secret. What looks like natural quick wit is almost always a well-practised habit of reflection that has crept earlier and earlier until it became 'instant'.

I walk through all of this, including the timeline of how that gap closes

And if you'd like to build those foundations properly, I run a free 2-hour masterclass where I teach the top three communication frameworks I use most, so you can speak with more clarity and stop rambling under pressure. It won't cost you a cent

Here's what I want you to leave with: You were never too slow, too awkward, or too far behind. You just hadn't been shown how this actually works. Now you have. Build your foundations until they run themselves, reflect for five honest minutes after the moments that matter, and watch what happens as those late ideas creep earlier and earlier until they land right when you need them. This is one of the most freeing truths I know: the communicator you wish you were is not someone else. It's you, a little further down a path you can start walking today. So go and take the first step. The next conversation is as good a place as any.

See you again soon!

Your Identity Is Built by Repetition, Not Motivation

noreply@blogger.com (H) — Tue, 14 Jul 2026 05:38:52 +0000

If someone asked you to describe yourself, your answer would probably sound something like this.

"I'm a disciplined person."

"I'm terrible at managing time."

"I'm an introvert."

"I'm confident."

"I'm not good with money."

"I'm someone who gives up easily."

Most of us think these statements describe who we are.

I'm no longer sure they do.

I think they describe who we've repeatedly been.

There's a difference.

Identity isn't something we discover.

It's something we quietly build through repetition.

We Give Motivation Too Much Credit

Whenever someone wants to change their life, motivation becomes the starting point.

People wait to feel inspired before exercising.

They wait to feel confident before speaking.

They wait to feel ready before starting a business.

The problem is that motivation is temporary.

Some mornings you have it.

Most mornings you don't.

If your identity depends on motivation, your identity changes with your mood.

That's a fragile foundation.

Every Action Leaves a Trace

Think about learning a new language.

The first lesson doesn't make you bilingual.

The tenth lesson doesn't either.

Even after fifty lessons, you might still feel like a beginner.

But something invisible is happening.

Each lesson is adding another piece to your identity.

One day, someone asks,

"What languages do you speak?"

Without realizing it, you answer,

"I speak Spanish."

Nothing magical happened that day.

Your identity simply caught up with your repetition.

Identity Is Built Like a Wall

Imagine building a brick wall.

One brick doesn't look impressive.

Neither do ten.

But if you keep placing one brick every day, eventually a wall appears.

Identity works the same way.

Every action is another brick.

Read today.

You've placed one brick.

Exercise today.

Another brick.

Keep your promise to yourself.

Another brick.

Most people quit because they don't see the wall.

They forget they're still laying bricks.

Motivation Starts the Journey. Repetition Finishes It

There is nothing wrong with motivation.

It can be a powerful starting point.

The problem is expecting it to stay forever.

Nobody feels motivated every single day.

Professionals understand this.

Athletes train when they don't feel like it.

Writers write when inspiration doesn't come.

Musicians practice on ordinary days.

They don't rely on emotion.

They rely on repetition.

Eventually, repetition becomes identity.

Your Brain Believes Evidence

One thing I've noticed about the human mind is that it doesn't listen to affirmations as much as it listens to evidence.

You can tell yourself,

"I'm confident."

But if you've avoided difficult conversations for years, your brain has different evidence.

You can tell yourself,

"I'm disciplined."

But if you've broken every promise you've made to yourself this month, your brain believes your actions instead.

Identity isn't created by what you say.

It's created by what you repeatedly prove.

Small Actions Change Self-Perception

People often underestimate small actions because the results aren't immediate.

Reading ten pages feels insignificant.

Saving a small amount of money feels insignificant.

Walking for twenty minutes feels insignificant.

Writing one page feels insignificant.

But the value of these actions isn't today's result.

It's tomorrow's identity.

Every repeated action sends the same message to your brain.

"This is who we are."

Eventually, your brain stops arguing.

It accepts the evidence.

The Identity Loop

I've started thinking about identity as a continuous loop.

Thought

↓

Decision

↓

Action

↓

Repetition

↓

Identity

↓

Future Decisions

The interesting part is that identity doesn't end the process.

It strengthens the next decision.

A runner doesn't debate whether to run.

A reader doesn't debate whether to read.

A disciplined person doesn't negotiate with every habit.

Their identity has already made the decision.

That's why positive habits become easier over time.

Not because the work changes.

Because the person changes.

Stop Asking "Who Am I?"

A better question is,

"What am I repeatedly becoming?"

Your identity is never fixed.

It's always under construction.

Every decision either reinforces the person you are today or introduces evidence for the person you want to become.

The process is happening whether you notice it or not.

Final Thoughts

Looking back, I don't think life changes because of one big decision.

It changes because of thousands of small repetitions that quietly reshape how we see ourselves.

The world celebrates dramatic transformations.

Real transformation is usually much quieter.

It's choosing to keep one promise today.

Then another tomorrow.

Then another next week.

Months later, people think you've become a different person.

In reality, you simply became the person your repeated actions had been building all along.

Identity isn't something you find.

It's something you practice.

Inner Architecture Rule #7

Your actions don't simply create results.

They create evidence.

And over time, your mind believes the evidence more than your intentions.

You Don't Become a Different Person. You Build a Different System.

noreply@blogger.com (H) — Tue, 14 Jul 2026 05:30:41 +0000

Over the last few months, I've been thinking about why real change is so difficult.

People decide to wake up early.

They promise themselves they'll stop procrastinating.

They start exercising.

They decide to read more, work harder, spend less time on social media, or become more disciplined.

For a few days, everything goes well.

Then, slowly, life returns to exactly the way it was before.

For a long time, I thought the problem was motivation.

Now I think motivation has very little to do with it.

The real problem is that we're trying to change the outcome while leaving the system that created it completely untouched.

We Focus on Behavior Because It's Visible

When we look at our lives, we mostly see the visible parts.

"I'm always distracted."

"I overthink everything."

"I can't stay consistent."

"I procrastinate."

"I lose motivation."

These feel like the problems.

But they're usually not.

They're simply the outputs of a much deeper system.

Imagine a factory producing defective products.

Would replacing the products fix the problem?

Of course not.

You would inspect the production line.

Human behavior works the same way.

Your actions are produced by an invisible system operating inside your mind.

If the system doesn't change, the output won't either.

A Simple Example

Suppose someone wants to become healthier.

Most people begin with a goal.

"I'll go to the gym every morning."

For a week, they force themselves to wake up early.

Then work becomes busy.

They skip one day.

Then another.

Eventually, the routine disappears.

The conclusion is usually:

"I don't have enough discipline."

Maybe.

Or maybe the system was never designed to succeed.

The person still sleeps late.

Still keeps unhealthy food at home.

Still spends hours on the phone before bed.

Still has no fixed morning routine.

Nothing underneath changed.

Only the goal changed.

Goals Don't Create Change. Systems Do.

A goal gives direction.

A system determines whether you ever reach it.

Think about two people preparing for a marathon.

Both have the same goal.

One depends on motivation.

The other builds a routine.

They prepare their clothes the night before.

Sleep at the same time every day.

Run regardless of mood.

Track progress every week.

After six months, their results look completely different.

Not because one wanted success more.

Because one trusted a system instead of emotions.

Your Life Already Runs on Systems

Whether you realize it or not, your life is already highly systematic.

You wake up at similar times.

You check your phone in a predictable pattern.

You eat at familiar hours.

You react to stress in familiar ways.

You spend money using similar habits.

You think similar thoughts every day.

Most of these patterns weren't consciously designed.

They simply evolved over time.

The problem is that unconscious systems often produce unconscious lives.

Identity Is an Output

One idea changed the way I think about personal growth.

We usually believe our identity creates our actions.

"I'm not disciplined."

"I'm not confident."

"I'm not a reader."

"I'm not good with money."

But what if identity works in the opposite direction?

Every repeated action quietly becomes evidence.

Read every day.

Eventually you believe you're a reader.

Exercise consistently.

Eventually you believe you're someone who values health.

Solve difficult problems.

Eventually you see yourself as someone capable of handling challenges.

Identity isn't built by positive thinking.

It's built by repeated proof.

The Architecture Behind Every Habit

I've started visualizing habits like this.

Environment
        ↓
Attention
        ↓
Thought
        ↓
Decision
        ↓
Action
        ↓
Repetition
        ↓
Identity

Most people try changing only one layer.

Action.

The stronger approach is to redesign the layers above it.

Change the environment.

Protect your attention.

Improve your decisions.

The actions begin changing naturally.

This Is Why Motivation Doesn't Last

Motivation is emotional.

Systems are structural.

Emotion changes every day.

Structure remains.

That's why highly disciplined people don't rely on feeling motivated.

They remove the need to make the same decision repeatedly.

The system decides for them.

The alarm rings.

The shoes are already ready.

The calendar already has time blocked.

The phone stays outside the room.

The decision was made yesterday.

Today's job is simply execution.

Rebuilding Your Inner Architecture

If I wanted to redesign my life today, I wouldn't begin with goals.

I'd begin with systems.

I'd ask:

What environment am I creating?
What consumes most of my attention?
Which habits are reinforcing my current identity?
Which decisions am I repeating unnecessarily?
What system is producing the results I'm complaining about?

Those questions lead to much deeper answers than asking,

"How do I become more motivated?"

Final Thoughts

I no longer think people become different overnight.

They become different because they quietly change the systems they live inside.

The change often looks invisible at first.

A small adjustment to a morning routine.

A better workspace.

Less time on social media.

Inner Architecture Rule #6

Your habits are not the problem.

They are the evidence.

If you want different results, stop fighting the behaviour.

Start redesigning the system that produces it.

You Don't Own Your Life Until You Own Your Decisions

noreply@blogger.com (H) — Tue, 14 Jul 2026 05:29:11 +0000

There is a question that has bothered me for years.

Do we really own our lives?

Most people would immediately answer, "Yes."

But if we observe carefully, the answer isn't that simple.

From childhood, our path is largely designed by someone else.

Study hard.

Get good grades.

Find a job.

Work for forty years.

Retire.

Very few people ever stop and ask a simple question:

"Is this the life I truly chose?"

Most of us spend decades becoming excellent workers.

Very few become architects.

This article is not about money.

It is not about entrepreneurship.

It is about ownership.

Ownership of your thoughts.

Ownership of your decisions.

Ownership of your future.

We Are Busy Building Someone Else's Dream

Think about your average weekday.

Someone else decides:

What is urgent.
Which meeting matters.
Which deadline comes first.
What success looks like.
When your day begins.
When your day ends.

You become incredibly productive.

But productive for whose vision?

Many people spend twenty years climbing a ladder without asking whether the ladder is leaning against the right wall.

Working hard isn't the problem.

Working without conscious ownership is.

The Difference Between a Labourer and an Architect

Imagine a construction site.

The labourer lays bricks.

The architect designs the building.

Both work hard.

Both are important.

But only one decides what gets built.

Life works the same way.

Most people execute.

Very few design.

We become experts at solving today's tasks but rarely spend time designing tomorrow's life.

Being busy is not the same as building.

Execution without direction creates movement.

Not progress.

Your Inner Architecture

As a software engineer, I've realized something fascinating.

Every great software product starts with architecture.

Before writing code, we ask questions.

What problem are we solving?

How will different components communicate?

Where should memory live?

How will the system scale?

What happens when something fails?

Without architecture, software becomes chaos.

Human life isn't any different.

Your inner architecture determines:

How you think.

How you make decisions.

How you respond to pressure.

How you define success.

How you spend your time.

External success is usually the result of internal architecture.

Not external circumstances.

The Invisible System Running Your Life

Most people believe they make decisions.

In reality, many decisions are automated.

Habits.

Social expectations.

Fear.

Comparison.

Comfort.

These become invisible programs running in the background.

Eventually, life starts happening automatically.

Wake up.

Work.

Scroll.

Sleep.

Repeat.

Without realizing it, you've handed control of your life to default settings.

Ownership Begins With Awareness

You cannot redesign a system you don't understand.

The first step is awareness.

Ask yourself:

Why am I pursuing this goal?

Whose definition of success am I following?

What would I still choose if nobody was watching?

Which decisions do I keep postponing?

Where am I reacting instead of creating?

These questions are uncomfortable.

That's exactly why they matter.

Becoming the Architect

Owning your life doesn't mean quitting your job.

It doesn't mean starting a business.

It doesn't mean rejecting responsibility.

It means becoming intentional.

Architects don't simply work.

They design.

Every decision becomes part of a larger blueprint.

Every habit supports a purpose.

Every action moves toward a chosen direction.

The goal isn't freedom from work.

The goal is freedom from unconscious living.

Systems Thinking Applies to Life Too

I often write about systems thinking in technology.

AI systems.

Software architecture.

Business workflows.

The same principle applies internally.

Your thoughts create beliefs.

Beliefs influence decisions.

Decisions become habits.

Habits shape identity.

Identity determines destiny.

Trying to change your life without changing this system is like repainting a building with a broken foundation.

Real transformation starts from within.

A Personal Reflection

Over the years, I've realized that success isn't only about building better products.

It's about building a better inner system.

A system that helps you think clearly.

Make conscious decisions.

Stay grounded under pressure.

And live according to values you actually chose.

That journey inspired me to write Mental System: Khud Ko Wapas Paane Ki Journey.

The book explores the inner architecture behind self-awareness, emotional clarity, and reclaiming ownership of your life in a world full of noise and expectations.

If this article resonated with you, I hope the book helps you continue that journey.

Final Thought

You may spend years building companies, products, careers, and relationships.

But the most important system you will ever design is the one inside your own mind.

Because the quality of your life is rarely determined by how hard you work.

It is determined by whether you are living someone else's blueprint...

or becoming the architect of your own.

About the Author

Bhupesh Patidar is a software engineer, AI product builder, and author who explores systems thinking in both technology and life. His work focuses on designing better AI systems, building purposeful products, and understanding the inner architecture that shapes human decisions.

Emotional Exhaustion Often Looks Like Laziness

noreply@blogger.com (H) — Tue, 14 Jul 2026 05:27:47 +0000

I think many people today are not actually lazy.

They are emotionally exhausted.

But because emotional exhaustion is not visible like physical illness, people misunderstand it very easily.

Even the person going through it often thinks: “Something is wrong with me.” “Why can’t I focus anymore?” “Why do simple tasks feel heavy?” “Why do I feel mentally tired all the time?”

From the outside, it looks like laziness.

But internally, the system is overloaded.

I have personally noticed that emotional exhaustion slowly changes the way a person thinks, reacts, and lives.

In the beginning, it does not look serious.

A person simply starts:

avoiding conversations
delaying work
feeling mentally low
losing excitement
disconnecting socially
spending more time alone

Then slowly even small responsibilities start feeling difficult.

Not because the person is weak.

But because the mind has been carrying emotional pressure for too long without proper recovery.

One thing people rarely understand is this:

The human mind can handle stress for some time.

But when emotional pressure becomes continuous, the nervous system starts entering survival mode.

And once that happens:

clarity drops
motivation disappears
focus weakens
patience reduces
overthinking increases

The body may still look normal.

But internally the mind feels tired all the time.

I think modern life is making this problem worse.

People are constantly dealing with:

comparison
pressure to succeed
relationship stress
financial anxiety
social expectations
information overload
emotional suppression

And most people never properly process any of it.

They just continue functioning.

Until one day the system slows down.

Then society labels it: “laziness.”

But many times the problem is deeper.

Emotionally exhausted people often want to do things.

They just do not have internal energy left.

I remember phases in my own life where mentally I wanted to improve things, work harder, and move forward. But internally there was too much emotional noise running in the background.

Unresolved stress quietly consumes mental energy.

That is why emotional exhaustion often creates strange behaviors:

sleeping too much
scrolling endlessly
avoiding important tasks
feeling disconnected from goals
difficulty making decisions
irritation without reason

People think discipline alone will solve this.

But sometimes the real need is recovery.

Not entertainment-based escape.

Real recovery.

There is a difference.

Temporary distraction gives stimulation.

Recovery gives nervous system relief.

I think this is why silence, reflection, journaling, physical movement, and emotional honesty are becoming very important today.

Because many people are carrying emotional weight continuously without even realizing it.

The dangerous part is that emotional exhaustion builds slowly.

It does not suddenly appear in one day.

It accumulates quietly through:

constant self-pressure
emotional suppression
toxic environments
overthinking
unresolved emotional patterns
pretending to be okay for too long

Eventually the mind stops cooperating.

And then even simple life starts feeling heavy.

I think people need to become more honest with themselves.

Not every low-energy phase means laziness.

Sometimes the mind is simply tired from carrying too much internally for too long.

And healing often begins when a person stops attacking themselves for being exhausted.

Because awareness creates recovery.

And recovery slowly brings clarity back again.

If these thoughts resonate with you, you may find deeper perspective in my book MENTAL SYSTEM . Read on Amazon

#InnerArchitecture #MentalHealth #EmotionalExhaustion #SelfAwareness #Psychology #Mindset #EmotionalIntelligence #MentalClarity #HumanBehavior #PersonalGrowth

The Modern World Is Quietly Training People To Lose Themselves

noreply@blogger.com (H) — Tue, 14 Jul 2026 05:24:52 +0000

I think one of the biggest problems in modern life is not stress.

It is disconnection from yourself.

People are becoming so busy reacting to the outside world that they no longer understand what is happening inside them.

Every day starts with noise: notifications, reels, opinions, trends, news, pressure, comparison, expectations.

Slowly the mind stops observing itself and starts operating on autopilot.

And this change happens very quietly.

Nobody suddenly wakes up and decides: “I want to lose myself.”

It happens little by little.

First people stop spending time alone.

Then they stop listening to their own thoughts.

Then they start adjusting themselves according to:

trends
social expectations
online validation
fear of missing out
comparison with others

After some years, many people no longer know:

what they genuinely enjoy
what kind of life they actually want
what gives them peace
what kind of people emotionally drain them
what they truly believe

Their whole personality becomes externally driven.

I have personally observed that many people today are constantly active but internally disconnected.

Their mind is always occupied, but rarely clear.

Even silence has become uncomfortable.

The moment people sit alone, they instantly pick up:

phones
music
social media
endless content

Because silence forces self-awareness.

And self-awareness can feel uncomfortable when someone has been disconnected from themselves for too long.

The modern system is also heavily reward-based.

Everything is becoming performance:

career
lifestyle
appearance
social image
relationships
even happiness

People slowly start building an identity that looks acceptable externally while internally feeling exhausted.

This is why many people say: “I don’t feel like myself anymore.”

The dangerous part is that society often normalizes this condition.

If someone is constantly busy, mentally distracted, emotionally tired, and disconnected from themselves, people simply call it: “adult life.”

But I don’t think humans are designed to live in continuous mental noise.

A mind without stillness slowly loses clarity.

And once clarity disappears, people become easier to influence.

That is why self-observation is becoming very important.

Simple questions can reveal a lot:

Why am I constantly mentally tired?
Which environments change my behavior?
What kind of content affects my thinking?
Am I living according to my own values or external pressure?
When was the last time I sat quietly without distraction?

Most people rarely ask these questions honestly.

They continue running inside systems they never consciously chose.

I think real self-growth starts when a person begins reconnecting with their own inner system again.

Not through motivation.

Not through endless consumption.

But through:

observation
silence
reflection
emotional honesty
reducing unnecessary noise

Because sometimes the biggest achievement is not becoming someone new.

It is returning to who you were before the world constantly pulled your attention away from yourself.

If these thoughts resonate with you, you may find deeper perspective in my book MENTAL SYSTEM Read on Amazon

#InnerArchitecture #SelfAwareness #MentalClarity #Psychology #HumanBehavior #Mindset #EmotionalIntelligence #PersonalGrowth #ModernLife #MentalHealth

Overthinking Is Not Deep Thinking. It’s Mental Looping

noreply@blogger.com (H) — Tue, 14 Jul 2026 05:19:44 +0000

Often confuse overthinking with intelligence.

If someone constantly analyses things, keeps imagining future scenarios, or thinks about every small detail for hours, people assume: “This person is a deep thinker.”

But overthinking and deep thinking are completely different things.

Deep thinking creates clarity.

Overthinking destroys it.

I have personally gone through phases where everything looked normal from the outside. Work was stable, life was moving, routines were fine. But internally, the same thoughts kept repeating again and again.

“Am I wrong?” “Should I explain myself more?” “Why are people not understanding me?” “What if things get worse later?”

The problem was not thinking itself.

The problem was that my mind got stuck in an emotional loop.

That is the most dangerous part of overthinking: it makes people feel like they are solving problems while they are actually draining themselves mentally.

If you observe carefully, overthinking usually has four signs:

The same thought repeats continuously
No real clarity comes out of it
The body starts feeling mentally tired
Action keeps getting delayed

That is not deep thinking.

That is mental looping.

It is similar to a computer system getting stuck and running the same process repeatedly in the background.

Deep thinking works differently.

A person observes, writes things down, breaks problems into parts, thinks from a neutral perspective, and eventually reaches a decision.

Overthinking is emotional.

Deep thinking is structured.

One thing I personally realized was this: as long as thoughts stay inside the mind, they feel heavy and chaotic.

The moment you start writing them down, clarity slowly begins to appear.

That is why journaling or reflective writing is so powerful.

Inside the mind, thoughts remain mixed together. Writing separates them.

Try this sometime: write down the exact thing that is mentally disturbing you.

Then below it, write:

What is the actual problem?
What exactly am I afraid of?
What is the worst possible outcome?
What can realistically be done?

You will notice that mental pressure immediately starts reducing.

Modern life has also made overthinking much worse.

People are constantly:

comparing themselves
consuming endless information
chasing validation
worrying about the future
measuring their life against other people’s highlights

As a result, the mind never truly enters a calm state anymore.

And when the mind never rests, thoughts slowly turn into loops.

Honestly, I think many people today are not deeply depressed.

They are mentally overloaded.

There is a difference.

Not every problem needs motivation.

Sometimes people simply need:

mental clarity
emotional space
silence
structured thinking

The solution to overthinking is not: “Stop thinking.”

The real solution is: change the way you think.

Because when the mind is structured, it becomes a tool for clarity.

But when it becomes uncontrolled, the same mind slowly exhausts the person from within.

If these thoughts connected with something you’ve been feeling internally, you may find deeper perspective in my book MENTAL SYSTEM Read on Amazon

#InnerArchitecture #MentalClarity #Overthinking #SelfAwareness #Psychology #Mindset #EmotionalIntelligence #MentalHealth #HumanBehavior #PersonalGrowth

Most People Don’t Need Motivation. They Need Mental Clarity

noreply@blogger.com (H) — Tue, 14 Jul 2026 05:18:06 +0000

Modern life has created a strange problem.

Almost everyone wants to feel motivated.

But very few people are actually searching for clarity.

That is why so many people consume:

motivational videos
productivity hacks
success quotes
self-improvement content

every single day…

yet still feel mentally stuck.

Because the real issue is often not lack of motivation.

The real issue is: mental confusion.

A confused mind cannot stay motivated for long.

Motivation Gives Energy. Clarity Gives Direction.

Motivation feels powerful because it creates temporary emotional energy.

For a few hours or a few days:

people feel ambitious
goals feel exciting
life feels controllable
action feels possible

But eventually that energy disappears.

Then the same cycle returns:

confusion
overthinking
doubt
emotional exhaustion

Why?

Because motivation without clarity creates movement without direction.

And movement without direction eventually becomes mental fatigue.

Many People Are Not Lazy. They Are Mentally Overloaded.

A lot of people today secretly believe: “I am becoming lazy.”

But often the truth is different.

Their mind is overloaded with:

too many choices
too many comparisons
too much information
too many expectations
too much future anxiety

The modern brain rarely rests anymore.

Every day people consume:

reels
opinions
news
AI content
success stories
pressure from social media
unrealistic lifestyles

Slowly the mind loses its internal clarity.

And once clarity disappears, even simple decisions start feeling heavy.

Confused Minds Constantly Search For External Signals

When clarity is weak, people start depending heavily on external validation.

They continuously ask:

“What should I do?”
“What is the best career?”
“Am I behind in life?”
“What are others achieving?”
“Which trend should I follow?”

The problem is not curiosity.

The problem is: they no longer trust their own internal system.

So instead of building inner understanding, they keep searching for more motivation.

But motivation cannot permanently solve inner confusion.

Motivation Often Becomes Emotional Escapism

Many people use motivation the same way others use entertainment.

It creates temporary emotional relief.

For example: someone feels lost, watches a powerful motivational video, feels emotionally charged, makes big plans, then returns to the same unclear lifestyle.

Nothing fundamentally changes.

Because emotional intensity is not the same as mental clarity.

Clarity requires:

deep reflection
observation
honesty
uncomfortable thinking
silence
self-analysis

And most people avoid these things.

Mental Clarity Changes Decision Quality

A clear mind behaves differently.

It:

says no more easily
avoids unnecessary chaos
stops chasing every trend
understands personal limits
recognizes emotional manipulation faster
makes calmer decisions
wastes less energy

Clarity creates stability.

And stability is becoming rare in modern life.

Today many people are mentally reactive.

Their emotions, routines, desires, and attention are constantly controlled by external systems.

That creates internal noise.

And noisy minds struggle to build meaningful lives.

Overthinking Is Often Unprocessed Confusion

People think overthinking means: “thinking too much.”

But many times overthinking is actually: thinking without structure.

The mind keeps replaying:

fears
conversations
future scenarios
regrets
uncertainty

without reaching understanding.

That loop drains emotional energy.

A clear mind does not necessarily think less.

It thinks more intentionally.

Silence Is Becoming Uncomfortable For A Reason

One of the biggest signs of modern mental confusion is this:

Many people cannot sit quietly with themselves anymore.

The moment silence appears, they instantly reach for:

phones
music
social media
endless stimulation

Why?

Because silence exposes mental clutter.

A distracted mind can temporarily avoid confusion.

A silent mind must confront it.

That is why clarity often begins in stillness.

Real Growth Begins When Observation Begins

Mental clarity does not appear automatically.

It develops through observation.

Simple questions can completely change awareness:

Why am I feeling mentally tired?
Which environments drain me?
Which people create confusion inside me?
Am I chasing goals I actually want?
Is this fear real or socially programmed?
What truly matters to me?

Most people rarely pause long enough to ask these questions honestly.

So they continue living in emotional autopilot.

Clarity Is More Powerful Than Motivation

Motivation can help someone start.

But clarity helps someone continue.

A motivated person may work hard for a few weeks.

A clear person can build a stable life for years.

Because clarity:

reduces internal conflict
simplifies decisions
creates emotional stability
improves focus
protects mental energy

And most importantly: clarity reconnects people with themselves.

The Real Problem Of Modern Life

The modern world is not just exhausting people physically.

It is fragmenting them mentally.

People are becoming:

overstimulated
emotionally reactive
comparison-driven
mentally distracted
disconnected from their own inner voice

That is why many people no longer need another motivational speech.

They need:

silence
reflection
emotional awareness
mental structure
honest self-observation

They need clarity.

Because once the mind becomes clear, motivation naturally becomes less important.

Clarity itself becomes energy.

Your Identity Is Built by Repetition, Not Motivation

noreply@blogger.com (H) — Tue, 14 Jul 2026 05:15:02 +0000

If someone asked you to describe yourself, your answer would probably sound something like this.

"I'm a disciplined person."

"I'm terrible at managing time."

"I'm an introvert."

"I'm confident."

"I'm not good with money."

"I'm someone who gives up easily."

Most of us think these statements describe who we are.

I'm no longer sure they do.

I think they describe who we've repeatedly been.

There's a difference.

Identity isn't something we discover.

It's something we quietly build through repetition.

We Give Motivation Too Much Credit

Whenever someone wants to change their life, motivation becomes the starting point.

People wait to feel inspired before exercising.

They wait to feel confident before speaking.

They wait to feel ready before starting a business.

The problem is that motivation is temporary.

Some mornings you have it.

Most mornings you don't.

If your identity depends on motivation, your identity changes with your mood.

That's a fragile foundation.

Every Action Leaves a Trace

Think about learning a new language.

The first lesson doesn't make you bilingual.

The tenth lesson doesn't either.

Even after fifty lessons, you might still feel like a beginner.

But something invisible is happening.

Each lesson is adding another piece to your identity.

One day, someone asks,

"What languages do you speak?"

Without realizing it, you answer,

"I speak Spanish."

Nothing magical happened that day.

Your identity simply caught up with your repetition.

Identity Is Built Like a Wall

Imagine building a brick wall.

One brick doesn't look impressive.

Neither do ten.

But if you keep placing one brick every day, eventually a wall appears.

Identity works the same way.

Every action is another brick.

Read today.

You've placed one brick.

Exercise today.

Another brick.

Keep your promise to yourself.

Another brick.

Most people quit because they don't see the wall.

They forget they're still laying bricks.

Motivation Starts the Journey. Repetition Finishes It

There is nothing wrong with motivation.

It can be a powerful starting point.

The problem is expecting it to stay forever.

Nobody feels motivated every single day.

Professionals understand this.

Athletes train when they don't feel like it.

Writers write when inspiration doesn't come.

Musicians practice on ordinary days.

They don't rely on emotion.

They rely on repetition.

Eventually, repetition becomes identity.

Your Brain Believes Evidence

One thing I've noticed about the human mind is that it doesn't listen to affirmations as much as it listens to evidence.

You can tell yourself,

"I'm confident."

But if you've avoided difficult conversations for years, your brain has different evidence.

You can tell yourself,

"I'm disciplined."

But if you've broken every promise you've made to yourself this month, your brain believes your actions instead.

Identity isn't created by what you say.

It's created by what you repeatedly prove.

Small Actions Change Self-Perception

People often underestimate small actions because the results aren't immediate.

Reading ten pages feels insignificant.

Saving a small amount of money feels insignificant.

Walking for twenty minutes feels insignificant.

Writing one page feels insignificant.

But the value of these actions isn't today's result.

It's tomorrow's identity.

Every repeated action sends the same message to your brain.

"This is who we are."

Eventually, your brain stops arguing.

It accepts the evidence.

The Identity Loop

I've started thinking about identity as a continuous loop.

Thought

↓

Decision

↓

Action

↓

Repetition

↓

Identity

↓

Future Decisions

The interesting part is that identity doesn't end the process.

It strengthens the next decision.

A runner doesn't debate whether to run.

A reader doesn't debate whether to read.

A disciplined person doesn't negotiate with every habit.

Their identity has already made the decision.

That's why positive habits become easier over time.

Not because the work changes.

Because the person changes.

Stop Asking "Who Am I?"

A better question is,

"What am I repeatedly becoming?"

Your identity is never fixed.

It's always under construction.

Every decision either reinforces the person you are today or introduces evidence for the person you want to become.

The process is happening whether you notice it or not.

Final Thoughts

Looking back, I don't think life changes because of one big decision.

It changes because of thousands of small repetitions that quietly reshape how we see ourselves.

The world celebrates dramatic transformations.

Real transformation is usually much quieter.

It's choosing to keep one promise today.

Then another tomorrow.

Then another next week.

Months later, people think you've become a different person.

In reality, you simply became the person your repeated actions had been building all along.

Identity isn't something you find.

It's something you practice.

Inner Architecture Rule #7

Your actions don't simply create results.

They create evidence.

And over time, your mind believes the evidence more than your intentions.

5 Industries That Will Be Minting Billionaires By 2031

noreply@blogger.com (H) — Tue, 07 Jul 2026 08:46:14 +0000

I am going to make 5 predictions.

Some of them will make you uncomfortable. Some will seem obvious in hindsight. All of them are backed by data that most people are ignoring right now because most people are too busy looking at what is already big to notice what is about to be.

Save this edition. Come back in 5 years. Tell me I was wrong.

I do not think you will.

PREDICTION 01

AI agents will replace entire business departments, and the people who own the agents will become the new millionaires

Everyone is talking about AI replacing jobs. That is the wrong conversation.

The right conversation is this: who owns the AI that does the work?

Right now, we are at the beginning of a shift from AI as a tool to AI as a workforce. In 2026, AI agents are already handling customer service, content creation, financial analysis, and legal research for companies that used to employ teams of 20.

The AI software market is projected to exceed $800 billion by 2030. But the people who will get truly wealthy from this are not the companies building AI. It is the freelancers, solopreneurs, and small operators who deploy AI agents to run businesses that used to require staff and pocket the margin that used to go to payroll.

A one person agency running 10 AI agents will outcompete a 50 person agency within 5 years. The question is whether you will be the one running the agents or the one being replaced by them.

The new millionaires will not be AI engineers. They will be the people who figure out how to own and operate AI workforces the same way the last generation owned and operated real estate.

PREDICTION 02

Humanoid robots will create the biggest wealth transfer since the internet and almost nobody outside Silicon Valley is paying attention

In 2025, humanoid robotics companies raised $3.2 billion globally, more than the total capital raised in the previous six years combined.

That is not a trend. That is a detonation.

Figure AI, Agility Robotics, Tesla Optimus. These are not science fiction projects. They are companies building physical machines that can stock shelves, assemble cars, care for elderly patients, and deliver packages. The global robotics market is projected to hit $218 billion by 2030 at 17% annual growth.

Here is what nobody is saying: the biggest opportunity is not in building robots. It is in owning the businesses that deploy them. The first restaurant chain to replace its kitchen staff with humanoid robots will not just cut costs. It will run at margins that make every competitor unviable.

Every major labour intensive industry on earth is about to be restructured. The people who see it coming and position their businesses now, even in small ways, will be the ones who look like geniuses in 2031.

PREDICTION 03

Mental health is the next trillion dollar industry and the entrepreneurs who treat it like a business will make a fortune

1 in 8 people on earth currently lives with a diagnosed mental illness. The global mental health market is projected to reach $600 billion by 2030.

Here is the uncomfortable reality: the traditional mental health system is broken. There are not enough therapists. Waitlists are months long. Sessions cost $200 an hour. Insurance covers almost none of it.

That gap between the scale of the problem and the capacity of the current system is one of the largest business opportunities on earth right now. AI powered therapy apps, digital mental health platforms, employer wellness programs, sleep tech, community based support models. Every one of these is in early innings. In 2025, US digital health startups alone raised $14.2 billion, with AI enabled companies capturing 54% of all funding.

The entrepreneur who builds the Spotify for mental health, affordable, accessible, always available, will not just make money. They will be one of the most important businesses of the decade.

Most people see mental health as a social issue. The entrepreneurs who see it as a design problem will be the ones who solve it and profit enormously in the process.

PREDICTION 04

The creator economy is not a trend. It is eating traditional media and the window to own a piece of it is closing faster than most people realise

In 2020, creator economy was a buzzword. In 2026, it is an industry generating over $250 billion annually and it is still in the early stages of eating every traditional media format that existed before it.

Newspapers are dying. Cable TV subscriptions are collapsing. Radio has been replaced by podcasts. Magazines have been replaced by newsletters and YouTube channels. Every single legacy media business is losing audience to individuals who built their own.

But here is the prediction most people miss: the next phase is not individual creators. It is creator owned media companies. The MrBeasts and Morning Brews of today are building what Disney and Conde Nast were in the 20th century, except they own everything, answer to no shareholders, and can pivot overnight.

The most valuable media companies of 2031 do not exist yet. They are being started right now by people who understand that audience is the new real estate and that owning an audience is worth more than owning a building.

The window to build an owned audience from zero is still open. But distribution is getting more competitive every month. The people who start now will look back in five years the same way early YouTube creators look back at 2008.

PREDICTION 05

Space is about to go from a government project to a private gold rush and the real money will not be in rockets

The commercial space economy is projected to hit $1 trillion by 2030.

SpaceX already proved that private companies can do what governments took decades to accomplish and do it cheaper and faster. But SpaceX is the railroad. The real money has always been made not by the company laying the tracks but by the businesses that run on top of them.

Satellite internet is already reshaping connectivity in rural and emerging markets. Earth observation data is being sold to agriculture companies, insurance firms, and governments. Space manufacturing is in its earliest stages. None of this is speculation. All of it has companies already funded and operating.

You do not need to launch a rocket to profit from the space economy. You need to be building businesses that only become possible once cheap satellite internet reaches every corner of the earth, because that moment is 3 years away.

One final thought.

Every single one of these predictions shares the same underlying logic: the biggest opportunities are always hiding inside the biggest problems. Mental health crisis. Labour shortages. Media collapse. Connectivity gaps. The entrepreneurs who look at broken systems and ask how do I build the thing that fixes this are the ones who end up on lists like these in five years.

The question is never whether the opportunity exists. It always does.

The question is whether you will move while most people are still debating whether it is real.

One Screenshot Can Change Everything

noreply@blogger.com (H) — Sun, 05 Jul 2026 09:42:55 +0000

Protect Your Sensitive Data Before It's Shared

In today's digital workplace, confidential information can leave your organization in seconds—not through emails or USB drives, but with a single screenshot.

One screenshot is all it takes to expose customer records, financial reports, source code, business strategies, and intellectual property.

Introducing inDefend Advanced

Intelligent Screenshot Protection for Modern Enterprises

inDefend Advanced helps organizations secure confidential information by detecting, preventing, and reporting unauthorized screenshot activities in real time.

Key Features

📸 Real-Time Screenshot Monitoring

Detect Print Screen and screenshot attempts instantly
Monitor user activities across endpoints
Generate detailed security logs

🚫 Block Sensitive Content Capture

Prevent screenshots of confidential applications
Enforce organization-wide security policies
Protect customer and business-critical information

🚨 Instant Alerts & Reporting

Notify security teams immediately
Comprehensive audit trails
Support compliance and forensic investigations

Why Organizations Choose inDefend Advanced

✔ Protect Intellectual Property ✔ Prevent Insider Data Leaks ✔ Meet Regulatory Compliance Requirements ✔ Reduce Risk of Data Exfiltration ✔ Strengthen Enterprise Security ✔ Complete Visibility & Control

A Single Screenshot Can Cost Millions

Sensitive data doesn't always leave through emails or file transfers.

It can be:

Customer databases
Financial statements
Source code
HR records
Business strategies
Legal documents
Healthcare information

Protect your business before a screenshot becomes a security incident.

Call to Action

Secure Your Business Today

Don't let a single screenshot become your next data breach.

Book a Live Demo and discover how inDefend Advanced helps your organization prevent data leakage in real time.

Honey Vig Web Developer Ajax,Jquery, ASP, PHP, dotNET

The Top 25% Isn't a Ranking. It's a Definition.

One Reasonable Definition of the Top 25%

Define the Job and Situation Before Defining the Person

Back to School Trends: What Sold in 2025

Designing With Uncertainty: How AI Supercharges Probabilistic Thinking

Probabilistic Thinking + AI

Be Cautious of Skewed Probabilistic Thinking Using AI

Practice Probabilistic Design with AI

Design for Likelihood, Not Certainty

Use Data as a Compass, Not a Map

Experiment as a Learning System

Keep Humans In the Loop

What Does HITL Look Like in Practice?

Designing for Human Judgment

The Risk of Getting It Wrong

Optimize for Resilience, Not Just Conversion

Build Systems That Adapt as Probabilities Change

Optimize for Long-term Outcomes, Not Just Short-term Wins

Plan For Uncertainty the Way You Plan For Scale

Conclusion

The 8 Most Brutal Business Quotes Ever Said And The Stories Behind Them

QUOTES YOU HAVE NEVER SEEN ON A POSTER

QUOTES THAT GOT LAUGHED AT, THEN PROVED EVERYONE WRONG

Matching AI Modality To User Intent: Designing The Right Interface

Myth of the Do-It-All Chatbot

Input: Why a Text Box is a Linguistic Barrier

Output: The Cognitive Cost of Reading Long Text

A Taxonomy of Input and Output Modalities

Task Audit: A Framework for Modality Selection

1. Contextual Inquiry and Observation

2. Focused Interviews

3. Collaborative Workshops

Input/Output Alignment Matrix

Case Study: Adaptive Modality for Field Technicians

The Problem: Cognitive Overload in High-Risk Environments

Research Methods: Capturing the Reality of the Field

The Resolution: A Multi-Modal Handoff Solution

Designing for the Environment

Where to Start

Modality Task Audit Field Template

Part 1: Physical Reality Check

Part 2: Cognitive Baseline

Part 3: Handoff Map #

Weaponizing And Defending The React Flight Protocol: Deserialization Sinks In RSCs

Flight On The Wire #

The Row Format #

The $ Prefix System #

This Is Not Just A Data Format #

Why Flight Is A Deserialization Sink #

Prototype Pollution #

Duck Typing and Thenables #

The Core Problem #

The Mechanics Of React2Shell #

The Root Cause #

The Gadget Chain #

Impact #

What Happened In The Wild #

The Fix #

Defenses, Ranked By Impact #

1. Input Validation On Server Actions (Zod, Valibot) #

2. The server-only Package #

3. CSRF Protections #

4. The hasOwnProperty Patch #

5. The Taint API #

6. WAFs #

What Came After React2Shell #

Why Accessibility Is An Operational Capability, Not A Feature

The Audit Trap

The AI Problem Nobody Wants To Name

Velocity and Accessibility Are Not Enemies #

What Enterprise-Ready Actually Looks Like

Patterns That Actually Scale

Constrain AI Before It Generates

Stop Hand-Rolling Complex Widgets

Capture Accessibility During Design Handoff

The Broader Business Impact

Systems, Not Sprints

M Office and imilar free

Recommendation

The `$` Prefix System #

2. The `server-only` Package #

4. The `hasOwnProperty` Patch #