You sit down to code.

You finally understand the problem. You hold the database schema in your head, you know exactly how the data needs to flow, and you are in the zone. Things are moving fast.

Then:

• A Slack notification pops up.
• Someone asks for a “quick” 5-minute PR review.
• An alert fires from your monitoring tool.

You switch tasks. You answer the question, approve the PR, and switch back.

But the flow is gone. You stare at your editor. You re-read your own code. You try to remember why you named that variable what you did. It takes you 15 minutes just to get back to the exact mental state you were in before the interruption.

That is context switching. And in 2026, it is quietly destroying developer productivity at a scale most teams do not fully understand.

Table of Contents

• What Context Switching Actually Means
• The Staggering Data for 2026
• Why It Hits Developers So Hard
• The Hidden Costs You Don’t See
• Why It Is Happening So Often Now
• What Actually Works (Practical Fixes)
• A Better Way to Structure Your Day
• My Thought

What Context Switching Actually Means

Context switching is when your brain is forced to drop one set of rules, logics, and goals, and load an entirely different set.

In software development, this is not just about “working on two things at once.” It looks like:

• Writing backend business logic → reviewing a frontend PR → debugging a production issue → attending a sprint planning meeting.
• Jumping from your IDE to Jira, to Confluence, to Figma, to Slack, and back again.
• Leaving human-written code to review AI-generated code, then returning to your own logic.

Every single switch exacts a cognitive toll. Your brain is not a computer monitor where you can just click a new tab and instantly render the page. It is a heavy engine that takes time to change tracks.

The Staggering Data for 2026

The cost of this mental friction is no longer a guessing game.

According to foundational research from UC Irvine, it takes an average of 23 minutes to fully recover deep focus after a major interruption.

Apply that to a modern engineering workday. Industry data from 2025 and 2026 shows that the average developer experiences 12 to 15 major context switches daily.

Do the math: 12 switches multiplied by 23 minutes of recovery time is over 4.5 hours of lost deep focus every single day [9]. Add the time spent actually dealing with the interruption, and you realize why you feel exhausted at 5 PM despite feeling like you “didn’t get much done.”

Financially, the impact is massive. Recent industry analysis estimates this “context-switching tax” costs companies roughly $78,000 per year, per mid-level developer, in lost productivity and delayed shipping.

Why It Hits Developers So Hard

Coding is not shallow work. It requires holding a massive, fragile house of cards in your working memory.

When you are deep in a feature, your brain is actively tracking:

• The business logic and edge cases.
• The data flow across the application.
• The file structure and module dependencies.
• The specific syntax and patterns of the codebase.

This is your mental context.

When a teammate asks a “quick question” about a completely different service, that house of cards collapses. Your brain flushes the current context to load the new one. When you return to your original task, you cannot just pick up where you left off. You have to rebuild the house of cards from scratch.

Researchers call this “attention residue.” Even after you switch back to your code, a part of your cognitive capacity is still stuck processing the previous task.

The Hidden Costs You Don’t See

The time lost to rebuilding context is obvious. But context switching does secondary damage that is arguably worse.

1. You Lose Flow State

Flow state is where the magic happens. It is when decisions feel automatic, the code writes itself, and you lose track of time. Context switching shatters flow instantly. If you are interrupted every 15 minutes, you will simply never enter flow state at all.

2. Quality Drops and Bugs Increase

When your mental model is incomplete because you just rushed back from a meeting, you miss edge cases. Human working memory can only hold a few pieces of information at once. Constant shifts increase the chances of introducing bugs and making poor architectural decisions.

3. AI Debugging Fatigue

In 2026, AI code generation was supposed to save us time. But it has introduced a new kind of context switch. Developers now bounce between writing their own code and reviewing massive blocks of AI-generated suggestions. According to the 2025 Stack Overflow Developer Survey, 45% of developers report that debugging AI-generated code is more time-consuming than writing it from scratch [14]. Shifting from “creator mode” to “auditor mode” over and over drains cognitive energy fast.

4. Shallow Work Takes Over

When your day is too fragmented to tackle complex problems, you default to easy wins. You reply to emails, move Jira tickets around, and tweak CSS. You feel incredibly busy, but the deep work that actually moves the needle gets pushed to tomorrow.

Why It Is Happening So Often Now

Why is this getting worse instead of better?

Tool Sprawl

Ten years ago, a developer needed a terminal, an editor, and version control. Today, you are jumping between GitHub, Slack, Jira, Zoom, Notion, Datadog, Figma, and an array of AI agents. In Atlassian’s State of Developer Experience Report, developers cited switching context between tools as one of their top three drags on productivity [10].

Always-On Culture

Tools like Slack have conditioned us to treat every notification as urgent. We have tied responsiveness to performance, rewarding the developer who answers in 30 seconds over the developer who goes offline for two hours to actually build the feature.

The “Maker vs. Manager” Schedule Clash

Managers work on one-hour intervals. A 30-minute meeting is just a standard block in their day. Makers (developers) need half-day blocks to do their work. Placing a single 30-minute meeting right in the middle of a developer’s afternoon destroys the entire half-day for deep work.

What Actually Works (Practical Fixes)

You do not need a perfect, utopian system to fix this. You just need to implement a few hard boundaries.

1. Block Deep Work Time Aggressively

Set 2 to 3-hour blocks on your calendar where you are completely unreachable.

• Close Slack.
• Put your phone in another room.
• Close your email tab.
  Treat this time with the same respect you would give a meeting with your CEO. This is where your actual job gets done.

2. Batch Your Shallow Tasks

Instead of checking Slack every time a red dot appears, check it deliberately. Process your messages, code reviews, and emails in dedicated 30-minute batches (e.g., once in the morning, once after lunch, once before logging off).

3. Write Down Your Context Before Switching

If you are forced to switch tasks—maybe an urgent production bug comes up—do not just abandon your editor. Take 60 seconds to write a comment exactly where you are:
// TODO: I just finished validating the payload. Next step is to write the DB insert and handle the unique constraint error.
This simple breadcrumb acts as a save state for your brain, drastically reducing the 23-minute recovery time when you return.

4. Limit Work in Progress (WIP)

Do not juggle four tickets at once because you are waiting on PR reviews. Stick to one primary task. If you are blocked, clearly communicate the block and pick up one (and only one) secondary task.

5. Push Back on Faux Urgency

Not everything needs a real-time response. It is a completely valid professional boundary to say:

• “I am in deep work right now, I will look at this around 2 PM.”
• “Can we discuss this asynchronously on the ticket instead of jumping on a call?”

A Better Way to Structure Your Day

If you have the autonomy, try to align your tasks with your brain’s natural energy levels:

• Morning (High Energy): Deep work. Writing complex logic, architectural design, hard debugging. Zero interruptions.
• Midday (Transition): Meetings, pair programming, answering questions, cross-team collaboration.
• Afternoon (Low Energy): Shallow work. Code reviews, writing documentation, organizing tomorrow’s tickets, clearing out the inbox.

My Thought

Context switching does not feel like a problem in the moment because you are always doing something. You are moving, clicking, typing, and answering.

But that is the trap. You are highly active, but completely ineffective.

True productivity in software engineering is not about typing faster, learning more keyboard shortcuts, or getting an AI to generate boilerplate. It is simply about staying on one complex problem long enough to actually solve it well.

If you want to improve your output and stop feeling burned out by Friday, do not try to squeeze more tasks into your day. Just reduce the number of times you switch between them.

Protect your focus. The code will follow.

The Problem Nobody Talks About

If you’ve ever tried to check whether a cosmetic ingredient is legal in South Korea, you know the pain:

• 🇰🇷 Government websites only in Korean
• 📄 Data buried in PDFs, not databases
• 🔍 No search functionality
• 🚫 No official API

For cosmetic brands trying to enter the Korean market, this means hours of manual research, expensive consultants, or just… guessing.

I decided to fix this.

What I Built

K-Beauty Cosmetic Ingredients API — A REST API with:

• ✅ 21,796 ingredients from official Korean sources
• ✅ INCI names, CAS numbers, Korean translations
• ✅ Regulatory status (Prohibited / Restricted / Not Listed)
• ✅ Concentration limits and conditions
• ✅ Fast JSON responses (<50ms)

Data comes directly from:

• MFDS (Ministry of Food and Drug Safety) — Korea’s FDA
• KCIA (Korea Cosmetic Industry Association)

Quick Example

Want to check if Retinol is restricted in Korea?

import requests

response = requests.get(
    "https://k-beauty-cosmetic-ingredients.p.rapidapi.com/v1/ingredient/inci",
    params={"q": "retinol"},
    headers={
        "X-RapidAPI-Key": "YOUR_API_KEY",
        "X-RapidAPI-Host": "k-beauty-cosmetic-ingredients.p.rapidapi.com"
    }
)

data = response.json()
print(data)

Response:

{
  "success": true,
  "count": 3,
  "data": [
    {
      "inci_name": "RETINOL",
      "kr_name": "레티놀",
      "cas_numbers": "68-26-8",
      "regulation_status": "Restricted",
      "purposes": "Skin conditioning"
    }
  ]
}

Now you know: Retinol is restricted (allowed with conditions) in Korean cosmetics. No PDF digging required.

Who Is This For?

API Endpoints

Tech Stack

For those curious about how it’s built:

• Backend: Python, FastAPI
• Database: SQLite (read-only mode)
• Server: Gunicorn + Uvicorn workers
• Infrastructure: AWS EC2, Docker
• Monitoring: Telegram alerts
• Distribution: RapidAPI

Why SQLite?

The data is essentially static (updated monthly). SQLite in read-only mode gives us:

• Zero configuration
• Fast reads
• No separate database server
• Easy backups

For a read-heavy API with ~22K records, it’s perfect.

Lessons Learned

1. Government Data is Messy

Scraping and normalizing data from multiple sources took 10x longer than building the API itself.

2. B2B > B2C for Niche APIs

Consumer apps want “safety scores.” Businesses want regulatory compliance data. They’re willing to pay for it.

3. Documentation Matters

Good docs = fewer support questions = more time for features.

Try It Free

The API is live on RapidAPI with a free tier (100 requests/month).

🔗 K-Beauty Cosmetic Ingredients API

📂 GitHub – Example Code

What’s Next?

• [ ] Monthly data updates
• [ ] More search filters
• [ ] Batch lookup endpoint
• [ ] Python/JS SDK packages

Questions?

Drop a comment below or reach out on RapidAPI. Happy to help!

If you’re working on cosmetic tech or regulatory compliance tools, I’d love to hear about your use case.

When most developers think about frontend development, they imagine components, UI elements, and responsive layouts.

What we rarely acknowledge is that every modern frontend is fundamentally a state machine — a system where the state drives the UI, and events drive state changes.

Add AI-driven features, predictive models, or automated agents, and your “simple” frontend suddenly becomes a complex web of interacting states, transitions, and events.

Frontends Are State Machines

Consider what a state machine is:

• States represent the current status of your system.
• Transitions are triggered by events (user clicks, API responses, timers, etc.).
• Actions happen as a result of transitions.

In a React app:

• Component props and internal state = states
• onClick, onChange, onSubmit = events that trigger transitions
• API calls, DOM updates, animations = actions

Even without AI, your frontend is already a state machine.

Example: A Login Form

A login form is deceptively simple:

• States: idle, typing, validating, success, error
• Events: user types, clicks submit, server responds
• Actions: show error, redirect, display spinner

Each state transition is predictable, but add AI into the mix, and things get interesting.

When AI Becomes a User

Modern frontends increasingly interact with AI:

• Autocomplete suggestions
• Real-time content generation
• Predictive form filling
• AI-powered dashboards

AI “users” don’t behave like humans. They:

• Trigger multiple events in milliseconds
• Read and write structured data
• Expect predictable API responses
• Chain multiple actions together

Suddenly, your state machine is no longer just a human interaction model — it’s a multi-agent reactive system.

Visualizing AI-Driven States

Imagine a text editor with AI autocomplete:

• Idle state: waiting for user input
• Typing state: user types a word
• Prediction state: AI suggests completions
• Insertion state: AI inserts suggested text
• Validation state: frontend checks syntax/format
• Error state: AI or server fails

Each state can be triggered by either the human or AI.

The complexity grows quickly — and it’s easy to introduce bugs if your state logic isn’t clean.

Tools That Help

Managing complex state machines can be overwhelming. Here are some approaches:

1. XState

   • Explicitly models states, events, and transitions
   • Great for complex interactions with AI agents

2. Redux / Zustand

   • Centralized state management
   • Makes side effects predictable

3. React Query / SWR

   • Handles async state and API calls efficiently
   • Helps when AI triggers multiple backend requests

4. Logging and Visualization

   • Track events, state transitions, and AI interactions
   • Prevents hidden bugs and race conditions

Best Practices

1. Think in States, Not Components

   • Map out all states your UI can be in
   • Include AI-triggered states in your diagrams

2. Keep Transitions Predictable

   • Avoid side effects that break the state machine
   • Make AI actions idempotent when possible

3. Separate Human and AI Flows When Needed

   • Some events only humans trigger
   • Some only AI triggers
   • Clear separation reduces unexpected bugs

4. Test AI Interactions

   • Use unit and integration tests for AI-triggered events
   • Simulate fast event chains

Why This Matters

Ignoring the state machine nature of your frontend leads to:

• Race conditions
• Unexpected behavior under AI usage
• Hard-to-debug bugs
• Poor user experience

Thinking in states makes your apps more predictable, scalable, and maintainable, especially as AI features become standard.

Conclusion

Your frontend is more than a collection of components and UI elements.

It’s a state machine — a system of states, events, and transitions.

AI doesn’t just add features. It adds complexity, speed, and new interactions.

Understanding your frontend as a state machine and accounting for AI interactions will help you:

• Build more reliable apps
• Reduce bugs and frustration
• Embrace the AI-driven future of web development

Modern frontend development isn’t just about humans anymore.

It’s about managing complex state machines that serve both humans and AI agents.

`
I have been writing technical content for about three years. In that time I developed a fairly confident set of beliefs about what makes content rank well. Keyword research, internal linking, page speed, backlink acquisition, content length. I followed the playbook. My traffic grew. I assumed I understood what I was doing.

Then, about six weeks ago, I started seriously looking at whether my content was being cited by ChatGPT, Perplexity AI, and Google Gemini. Not just vaguely appearing somewhere, but actually being used as a source when someone asked a question my posts directly answer.

The results were uncomfortable. And almost everything I had been confident about turned out to be either wrong or only partially true when applied to how AI search actually works.

Here are the five beliefs that took the biggest hits.

Belief 1: “If I rank on Google, AI tools will find my content”

This was my first and most fundamental assumption. It made intuitive sense. Google crawls your content, AI tools train on or retrieve from web data, if your content is good enough to rank it must be getting picked up.

The reality is messier. Perplexity AI runs its own crawler, called PerplexityBot, independently of Google’s index. ChatGPT Browse uses Bing’s index, not Google’s. Google’s own Gemini model pulls from Google’s AI Overviews system, which uses a separate retrieval layer on top of the regular index. These are distinct systems with distinct access requirements.

More importantly, even when AI tools can reach your content, whether they cite it depends on how the content is structured, not on whether it already ranks. I have posts sitting at position 2 on Google that get zero AI citations. I found competitor posts with weaker Google authority getting cited constantly because their content is structured for fast answer extraction.

Google ranking and AI search visibility are related but not the same thing. I had been treating them as identical.

Belief 2: “Longer, more comprehensive content always wins”

The long-form comprehensive guide has been the backbone of content strategy for years. Cover everything, go deeper than anyone else, build the definitive resource. That approach has served me reasonably well on Google.

AI search does not reward comprehensiveness in the same way. What it rewards is answer clarity and answer position. A 3,000-word guide that spends the first 400 words on background and context before getting to the actual answer will consistently lose AI citations to a 900-word post that answers directly in the first paragraph.

I had a post last year that I was particularly proud of. Exhaustive research, multiple expert perspectives, thorough examples. It ran nearly 4,500 words. My GEO score on it, when I eventually checked with the GoForTool AI SEO Analyzer, was 22 out of 100. The main issue was answer position – my first real answer to the implied question appeared at word 490. The post was comprehensive and effectively invisible to AI search.

Length is not the problem. Delay is the problem.

Belief 3: “Writing naturally and avoiding keyword stuffing is enough”

I was actually proud of this one. I had moved away from aggressive keyword optimization toward what I thought of as writing for humans first. Readable sentences, natural language, no awkward repetition of target phrases.

It turns out there is a middle layer between keyword stuffing and natural writing that I was completely missing: entity specificity.

AI systems build their understanding of content through named entities – verifiable, specific things that appear in training data. When I write “a popular JavaScript bundler,” that phrase means nothing to an LLM. When I write “Vite 5.2” or “esbuild 0.19,” those are entities the AI can map to its knowledge graph, confirm as real, and use to understand what my content is about.

My natural writing was full of vague references that felt fine to me as a human reader but scored near zero for entity density. I went through my top ten posts after learning this and found phrases like “major cloud providers,” “modern browsers,” “leading frameworks” throughout. Every one of those is a missed citation opportunity.

The fix is not keyword stuffing. It is just being specific about things you were already referencing vaguely.

Belief 4: “Schema markup is for e-commerce and news sites”

I knew schema markup existed. I had implemented basic Article schema on my posts at some point because a tutorial said to. I thought of it as a nice-to-have for rich snippet eligibility and mostly irrelevant for the kind of technical writing I do.

This was probably my most expensive misconception.

FAQPage schema turns out to be the highest single-impact technical change you can make for AI search visibility. Here is why: each question-answer pair you encode in FAQPage schema becomes a pre-packaged extraction unit that Google’s Gemini model can pull directly into an AI Overview response. It does not have to infer your answer from prose. It has a structured, verified answer sitting in machine-readable JSON.

A post with three FAQPage pairs gets three independent citation opportunities, each potentially triggering for a different related query. A post with no FAQPage schema requires the AI to do substantially more interpretive work to extract a citable answer, and it will often choose a different source instead.

I now add FAQPage schema to every post I publish. GoForTool generates it for me based on the page content so I am not writing JSON from scratch each time. The time cost is about ten minutes. The citation impact has been significant enough that I consider it mandatory.

Belief 5: “My site’s domain authority protects me from newer competitors”

Three years of consistent publishing, some decent backlinks, a growing audience. I had assumed this created a kind of moat. Newer sites and shorter posts would struggle to outrank me because they lacked the authority signals I had built up.

AI search does not care about domain authority in the traditional sense. It cares about how well a specific piece of content is structured for extraction. A two-month-old blog with a well-structured post that leads with a direct answer, names specific entities, and has proper FAQPage schema will get cited over a three-year-old site whose well-ranking post opens with four paragraphs of context.

I found this out the hard way when auditing which pages were getting cited for queries in my topic area. Several were from sites I had never heard of, published recently, with zero of the traditional authority signals I had spent years accumulating. Their GEO scores were high. Mine were not. That was the whole story.

What I have actually changed

I am not throwing out everything I know about traditional SEO. That still matters and the signals still compound. But I added a few specific things to my workflow that address these gaps.

Every post now opens with a direct answer to the question implied by its title, within the first hundred words. Not context, not a story, not a “have you ever wondered” opener. An answer.

I check entity density before publishing. Anything vague gets a specific name.

FAQPage schema goes on every post. I use GoForTool’s AI SEO Analyzer as a pre-publish check – it runs the full audit, flags whatever I missed, and generates the schema so I do not have to write it by hand.

My robots.txt now has explicit Allow entries for GPTBot, PerplexityBot, ClaudeBot, and Google-Extended. I had two of those blocked without realizing it.

The posts I have applied this to consistently started getting Perplexity citations within two to three weeks. The posts I have not touched yet are still sitting with GEO scores in the 20s and 30s and zero AI citations. The correlation is hard to ignore.

Which of these beliefs did you share? Or have you hit a different wall with AI search that I have not covered here? Drop it in the comments – genuinely curious how this maps to other people’s experience.

seo #ai #webdev #career`

Quick commerce — the model where groceries, medicine, and daily essentials arrive at your door in under 30 minutes — is no longer a novelty. It’s infrastructure. In most Indian metros, it’s quietly become as essential as electricity or water for millions of urban households.

But there’s a workforce behind every delivery, and that workforce is operating in a financial environment that’s genuinely precarious — not because of bad intentions from platforms, but because the entire financial services industry was built for a different era of work.

We spent Phase 1 sitting with that problem. Not rushing to solutions. Just understanding what’s actually happening on the ground for delivery partners. What we found was harder to ignore than we expected.

The Income Reality Nobody Talks About

Here’s what a delivery partner’s earnings week looks like in practice. Monday is fine — steady orders, decent pay. Tuesday it rains. Not just rains, but pours. Orders slow, roads are dangerous, and the partner makes a call to stay home. Wednesday the platform runs a maintenance window from 11am to 2pm. Thursday is normal. Friday there’s a surge — but only in certain zones, and this partner isn’t in one of them.

Total weekly earnings: unpredictable. Completely.

Not “variable” in the way a commission-based salesperson might experience. Actually unpredictable — governed by weather, platform uptime, demand zones, time of day, city events, and a dozen other factors outside anyone’s control.

And yet — rent is monthly. EMIs are monthly. School fees are monthly. The rhythm of expenses doesn’t adjust because the rhythm of income is erratic. That mismatch is where the real pressure lives.

Why Traditional Systems Break Down Here

We looked hard at what already exists — insurance products, income protection schemes, government welfare frameworks — and tried to understand why delivery partners either don’t use them or can’t access them in any meaningful way.

The answer keeps coming back to the same set of structural mismatches:

Eligibility

Most products require proof of stable income. Delivery partners can’t provide that in any form that traditional underwriting recognizes. Payslips don’t exist. Bank statements show irregular deposits. The system simply says: insufficient data.

Premiums

Fixed monthly premiums don’t work when income is variable. On a bad week, a ₹200/month premium can feel impossible. On a good week, the same person might happily pay ₹400. No existing product bends that way.

Claims

The risks that actually hit delivery partners — a bad weather day, a platform outage, a zone with no orders — are frequent, short-lived, and small. Traditional claims processes are built for large, rare, documented events. The math doesn’t work for micro-disruptions.

Trust

Many delivery partners have had bad experiences with financial products — hidden charges, complicated terms, rejected claims. The trust deficit is real, and any solution has to earn its way past it, not assume it away.

The problem isn’t that delivery partners are uninsurable. It’s that every existing product was designed assuming the user has a stable income, a formal employer, and the bandwidth to navigate complex paperwork. Remove those assumptions and almost every product falls apart.

What Phase 2 Is Really About

We’re now deep in the design phase — and what that means in practice is less about building features and more about asking hard questions about the right foundations.

• What does “risk” actually look like for this workforce — at the level of a single shift, a single day, a single week?
• How do you think about eligibility when the traditional signals don’t exist?
• What does a fair, transparent, and genuinely useful protection product feel like for someone who has good reason to distrust financial services?

We’re working through the logic of how coverage could flex with the nature of gig work — responding to the same real-time signals that already govern whether a partner earns or doesn’t on a given day. The idea isn’t complicated. The execution is.

There are a lot of ways to get this wrong. You can build something technically elegant that nobody trusts. You can build something workers want but that isn’t financially viable. You can over-engineer a solution that adds friction at the exact moments people need it most. We’re trying to avoid all of those failure modes at once, which means Phase 2 is slower and more deliberate than Phase 1 was.

The Questions We’re Still Sitting With

Honest answer: there are a few things we haven’t fully resolved yet, and we’d rather say that than paper over it with confident language.

On data: What are the right signals to assess risk in real time without creating a system that feels intrusive or penalizing to the people it’s supposed to help? There’s a version of “real-time risk assessment” that becomes surveillance. We’re not building that version.

On onboarding: The moment someone first encounters this product is critical — especially given the trust deficit we mentioned. Simplicity isn’t just a UX preference here, it’s a survival requirement for adoption.

On sustainability: We want to build something that actually helps delivery partners, not a product that looks good on paper and quietly extracts value from a vulnerable workforce. Getting the incentive structures right is an ongoing design problem, not a solved one.

What Comes Next

Once the core framework is stress-tested, we move into a pilot phase with a real cohort of delivery partners. The goal isn’t just to validate that the product works — it’s to find out whether it meaningfully reduces the financial anxiety that’s become a constant undercurrent in this workforce. If it doesn’t do that, we haven’t solved anything.

More details on the pilot as we get closer.

Why We’re Writing This at All

The build-in-public instinct for us isn’t about marketing. It’s accountability. When you say out loud that you’re trying to build something fair, useful, and honest for a workforce that’s been underserved — you’re setting a standard you have to live up to. That’s the point.

Q-commerce isn’t slowing down. The workforce behind it isn’t going away. The gap in financial protection for these workers is real, documented, and solvable. We’re working on it.

If you’ve worked with gig workers, built in fintech or insurtech, or thought hard about alternative data and financial inclusion — we’d genuinely love to hear from you. The problems we’re navigating aren’t unique to us, and good thinking doesn’t have to be either.