Stop Ignoring These Frontend Skills—You’ll Need Them Sooner Than You Think

 

Let’s be honest: the way we create for the web is evolving at a pace that many people are reluctant to acknowledge.

What was once considered “nice to have” just a year ago is quickly turning into a “must-have” today. If you’re not keeping an eye on these changes, you’ll definitely notice the impact soon.

Here are the frontend skills I believe are shifting from “maybe later” to “learn now” over the next 2–3 years:

1. AI-Powered Coding Tools : Tools like Copilot and Codeium are more than just a novelty. They’re rapidly becoming essential parts of our daily workflow. If you can effectively guide, review, and enhance the suggestions that AI provides, you’ll be able to deliver your projects faster and with greater intelligence.

2. Real Accessibility & Inclusive Design: These days, accessibility is something we expect rather than just admire. Creating experiences that cater to all users right from the beginning will really make you stand out. Very soon, it will become essential for every project.

3. Building for Every Device :These days, it’s not just about web and mobile anymore. Your creations need to look fantastic on every screen - whether it’s a smart TV or whatever new tech comes our way. Responsive and resilient user interfaces are now the standard we should all aim for.

4. Performance Matters : Let’s face it, nobody wants to deal with sluggish apps. Taking the time to profile, optimize, and genuinely care about the user experience is what sets the good apart from the truly great.

5. Privacy-First Frontends; Trust is everything. Make privacy clear, easy to understand, and simple to control in your user interface. For many users - and regulators - this is already a deal-breaker.

6. Strong Fundamentals, Flexible Stack: Frameworks may evolve, but the top developers really grasp the essential concepts and can easily switch between different tools. Stay curious. Keep learning. Don’t limit yourself to just one stack.

What’s Next?

Get ready for more AI in your development tools. The demand for user-friendly and privacy-conscious interfaces is only going to rise. Expect lightning-fast, resilient apps to become standard on every device.

By mastering these skills, you won’t just be securing your future career; you’ll also unlock opportunities for roles and projects that you might not even be aware of yet. If you’re aiming for bigger chances—and want the confidence to embrace them—now’s the time to start.

Feel free to drop a comment if you’d like an invite, or send me a DM if you think there’s a skill that should be added to the list.

What are you currently learning to stay ahead? Let’s chat about it in the comments!

Stop Building "Dead" Websites. (The Pixel-Perfect Era is Over)

 

Your $50k website is officially a dinosaur. 🦖

For a decade, we’ve been obsessed with "Pixel Perfection." We argued over hex codes, debated the radius of a button, and spent months perfecting "Click Paths."

The reality? In 2026, your users don’t want to click through your beautiful menu. They want an answer.

We are witnessing the violent transition from Deterministic UI (the static site you built) to Generative UI (the interface that builds itself around the user).

---

1. The Netflix-ification of Everything

Remember when you had to browse "Genres" to find a movie? Now, Netflix builds a unique homepage for you the second you log in.

If your SaaS or E-commerce site still looks the same for a first-time visitor as it does for a 5-year veteran, you aren't "consistent"—you’re irrelevant. Generative UI means the interface morphs based on intent. If the AI detects a user is frustrated, the "Help" button shouldn't just be there; it should be the only thing there.

2. Accessibility is your new SEO

Here is a hard truth: If an AI Agent (like Gemini or GPT-6) can’t "crawl" your site and understand it instantly, you don't exist.

• Old way: Making your site accessible to be "nice."
• New way: Using Semantic HTML because if the AI can’t read your site, it won't recommend you to the millions of people using Voice Search and AI Personal Assistants.

3. The "Invisible" UI (Example: Uber)

The most successful interface of the last decade is the Uber map. Why? Because it’s invisible. You don’t "navigate" a menu to find a car. You see a map, you see a car, you press one button.

The future isn't more buttons; it’s Zero UI. It’s systems that use token-driven logic to automate the boring stuff so humans can do the creative stuff.

---

The Bottom Line:

Stop building for browsers. Start building for behaviors.

If your design system requires a manual to understand, you’ve already lost. The winners of 2026 will be the ones who blend high-end aesthetics with "Invisible" AI logic.

---

I’m calling it: The "Sidebar and Dashboard" layout is officially dead. Who’s brave enough to disagree? 👇

Drop a comment below: Is your team still stuck in the "Pixel-Perfect" trap, or are you building for the AI era?

Identifying Necessary Transparency Moments In Agentic AI (Part 1)

 Designing for agentic AI requires attention to both the system’s behavior and the transparency of its actions. Between the black box and the data dump lies a more thoughtful approach.

explores how to map decision points and reveal the right moments to build trust through clarity, not noise.

Designing for autonomous agents presents a unique frustration. We hand a complex task to an AI, it vanishes for 30 seconds (or 30 minutes), and then it returns with a result. We stare at the screen. Did it work? Did it hallucinate? Did it check the compliance database or skip that step?

We typically respond to this anxiety with one of two extremes. We either keep the system a Black Box, hiding everything to maintain simplicity, or we panic and provide a Data Dump, streaming every log line and API call to the user.

Neither approach directly addresses the nuance needed to provide users with the ideal level of transparency.

The Black Box leaves users feeling powerless. The Data Dump creates notification blindness, destroying the efficiency the agent promised to provide. Users ignore the constant stream of information until something breaks, at which point they lack the context to fix it.

We need an organized way to find the balance. In my previous article, “Designing For Agentic AI”, we looked at interface elements that build trust, like showing the AI’s intended action beforehand (Intent Previews) and giving users control over how much the AI does on its own (Autonomy Dials). But knowing which elements to use is only part of the challenge. The harder question for designers is knowing when to use them.

How do you know which specific moment in a 30-second workflow requires an Intent Preview and which can be handled with a simple log entry?

This article provides a method to answer that question. We will walk through the Decision Node Audit. This process gets designers and engineers in the same room to map backend logic to the user interface. You will learn how to pinpoint the exact moments a user needs an update on what the AI is doing. We will also cover an Impact/Risk matrix that will help to prioritize which decision nodes to display and any associated design pattern to pair with that decision.

Transparency Moments: A Case Study Example 

Consider Meridian (not real name), an insurance company that uses an agentic AI to process initial accident claims. The user uploads photos of vehicle damage and the police report. The agent then disappears for a minute before returning with a risk assessment and a proposed payout range.

Initially, Meridian’s interface simply showed Calculating Claim Status. Users grew frustrated. They had submitted several detailed documents and felt uncertain about whether the AI had even reviewed the police report, which contained mitigating circumstances. The Black Box created distrust.

To fix this, the design team conducted a Decision Node Audit. They found that the AI performed three distinct, probability-based steps, with numerous smaller steps embedded:

• Image Analysis
  The agent compared the damage photos against a database of typical car crash scenarios to estimate the repair cost. This involved a confidence score.
• Textual Review
  It scanned the police report for keywords that affect liability (e.g., fault, weather conditions, sobriety). This involved a probability assessment of legal standing.
• Policy Cross Reference
  It matched the claim details against the user’s specific policy terms, searching for exceptions or coverage limits. This also involved probabilistic matching.

The team turned these steps into transparency moments. The interface sequence was updated to:

• Assessing Damage Photos: Comparing against 500 vehicle impact profiles.
• Reviewing Police Report: Analyzing liability keywords and legal precedent.
• Verifying Policy Coverage: Checking for specific exclusions in your plan.

The system still took the same amount of time, but the explicit communication about the agent’s internal workings restored user confidence. Users understood that the AI was performing the complex task it was designed for, and they knew exactly where to focus their attention if the final assessment seemed inaccurate. This design choice transformed a moment of anxiety into a moment of connection with the user.

Applying the Impact/Risk Matrix: What We Chose to Hide #

Most AI experiences have no shortage of events and decision nodes that could potentially be displayed during processing. One of the most critical outcomes of the audit was to decide what to keep invisible. In the Meridian example, the backend logs generated 50+ events per claim. We could have defaulted to displaying each event as they were processed as part of the UI. Instead, we applied the risk matrix to prune them:

• Log Event: Pinging Server West-2 for redundancy check.
  • Filter Verdict: Hide. (Low Stakes, High Technicality).
• Log Event: Comparing repair estimate to BlueBook value.
  • Filter Verdict: Show. (High Stakes, impacts user’s payout).

By cutting out the unnecessary details, the important information — like the coverage verification — was more impactful. We created an open interface and designed an open experience.

This approach uses the idea that people feel better about a service when they can see the work being done. By showing the specific steps (Assessing, Reviewing, Verifying), we changed a 30-second wait from a time of worry (“Is it broken?”) to a time of feeling like something valuable is being created (“It’s thinking”).

Let’s now take a closer look at how we can review the decision-making process in our products to identify key moments that require clear information.

The Decision Node Audit

Transparency fails when we treat it as a style choice rather than a functional requirement. We have a tendency to ask, “What should the UI look like?” before we ask, “What is the agent actually deciding?”

The Decision Node Audit is a straightforward way to make AI systems easier to understand. It works by carefully mapping out the system’s internal process. The main goal is to find and clearly define the exact moments where the system stops following its set rules and instead makes a choice based on chance or estimation. By mapping this structure, creators can show these points of uncertainty directly to the people using the system. This changes system updates from being vague statements to specific, reliable reports about how the AI reached its conclusion.

In addition to the insurance case study above, I recently worked with a team building a procurement agent. The system reviewed vendor contracts and flagged risks. Originally, the screen displayed a simple progress bar: “Reviewing contracts.” Users hated it. Our research indicated they felt anxious about the legal implications of a missing clause.

We fixed this by conducting a Decision Node Audit. I’ve included a step-by-step checklist for conducting this audit at the conclusion of this article.

We ran a session with the engineers and outlined how the system works. We identified “Decision Points” — moments where the AI had to choose between two good options.

In standard computer programs, the process is clear: if A happens, then B will always happen. In AI systems, the process is often based on chance. The AI thinks A is probably the best choice, but it might only be 65% certain.

In the contract system, we found a moment when the AI checked the liability terms against our company rules. It was rarely a perfect match. The AI had to decide if a 90% match was good enough. This was a key decision point.

Figure 1: This diagram shows how to connect a hidden system decision based on probability (an Ambiguity Point) to a visible moment of explanation for the user (a Transparency Moment).

Once we identified this node, we exposed it to the user. Instead of “Reviewing contracts,” the interface updated to say: “Liability clause varies from standard template. Analyzing risk level.”

This specific update gave users confidence. They knew the agent checked the liability clause. They understood the reason for the delay and gained trust that the desired action was occurring on the back end. They also knew where to dig in deeper once the agent generated the contract.

To check how the AI makes decisions, you need to work closely with your engineers, product managers, business analysts, and key people who are making the choices (often hidden) that affect how the AI tool functions. Draw out the steps the tool takes. Mark every spot where the process changes direction because a probability is met. These are the places where you should focus on being more transparent.

As shown in Figure 2 below, the Decision Node Audit involves these steps:

1. Get the team together: Bring in the product owners, business analysts, designers, key decision-makers, and the engineers who built the AI. For example,

   Think about a product team building an AI tool designed to review messy legal contracts. The team includes the UX designer, the product manager, the UX researcher, a practicing lawyer who acts as the subject-matter expert, and the backend engineer who wrote the text-analysis code.

2. Draw the whole process: Document every step the AI takes, from the user’s first action to the final result.

   The team stands at a whiteboard and sketches the entire sequence for a key workflow that involves the AI searching for a liability clause in a complex contract. The lawyer uploads a fifty-page PDF → The system converts the document into readable text. → The AI scans the pages for liability clauses. → The user waits. → Moments or minutes later, the tool highlights the found paragraphs in yellow on the user interface. They do this for many other workflows that the tool accommodates as well.

3. Find where things are unclear: Look at the process map for any spot where the AI compares options or inputs that don’t have one perfect match.

   The team looks at the whiteboard to spot the ambiguous steps. Converting an image to text follows strict rules. Finding a specific liability clause involves guesswork. Every firm writes these clauses differently, so the AI has to weigh multiple options and make a prediction instead of finding an exact word match.

4. Identify the ‘best guess’ steps: For each unclear spot, check if the system uses a confidence score (for example, is it 85% sure?). These are the points where the AI makes a final choice.

   The system has to guess (give a probability) which paragraph(s) closely resemble a standard liability clause. It assigns a confidence score to its best guess. That guess is a decision node. The interface needs to tell the lawyer it is highlighting a potential match, rather than stating it found the definitive clause.

5. Examine the choice: For each choice point, figure out the specific internal math or comparison being done (e.g., matching a part of a contract to a policy or comparing a picture of a broken car to a library of damaged car photos).

   The engineer explains that the system compares the various paragraphs against a database of standard liability clauses from past firm cases. It calculates a text similarity score to decide on a match based on probabilities.

6. Write clear explanations: Create messages for the user that clearly describe the specific internal action happening when the AI makes a choice.

   The content designer writes a specific message for this exact moment. The text reads: Comparing document text to standard firm clauses to identify potential liability risks.

7. Update the screen: Put these new, clear explanations into the user interface, replacing vague messages like “Reviewing contracts.”

   The design team removes the generic Processing PDF loading spinner. They insert the new explanation into a status bar located right above the document viewer while the AI thinks.

8. Check for Trust: Make sure the new screen messages give users a simple reason for any wait time or result, which should make them feel more confident and trusting.

Figure 2: A product team maps the decision nodes of an AI legal tool to design transparent interface messages. (Comic generated using Google Gemini/Nano Banana)

The Impact/Risk Matrix

Once you look closely at the AI’s process, you’ll likely find many points where it makes a choice. An AI might make dozens of small choices for a single complex task. Showing them all creates too much unnecessary information. You need to group these choices.

You can use an Impact/Risk Matrix to sort these choices based on the types of action(s) the AI is taking. Here are examples of impact/risk matrices:

First, look for low-stakes and low-impact decisions.

Low Stakes / Low Impact

• Example: Organizing a file structure or renaming a document.
• Transparency Need: Minimal. A subtle toast notification or a log entry suffices. Users can undo these actions easily.

Then identify the high-stakes and high-impact decisions.

High Stakes / High Impact

• Example: Rejecting a loan application or executing a stock trade.
• Transparency Need: High. These actions require Proof of Work. The system must demonstrate the rationale before or immediately as it acts.

Consider a financial trading bot that treats all buy/sell orders the same. It executes a $5 trade with the same opacity as a $50,000 trade. Users might question whether the tool recognizes the potential impact of transparency on trading on a large dollar amount. They need the system to pause and show its work for the high-stakes trades. The solution is to introduce a Reviewing Logic state for any transaction exceeding a specific dollar amount, allowing the user to see the factors driving the decision before execution.

Mapping Nodes to Patterns: A Design Pattern Selection Rubric

Once you have identified your experience’s key decision nodes, you must decide which UI pattern applies to each one you’ll display. In Designing For Agentic AI, we introduced patterns like the Intent Preview (for high-stakes control) and the Action Audit (for retrospective safety). The decisive factor in choosing between them is reversibility.

We filter every decision node through the impact matrix in order to assign the correct pattern:

High Stakes & Irreversible: These nodes require an Intent Preview. Because the user cannot easily undo the action (e.g., permanently deleting a database), the transparency moment must happen before execution. The system must pause, explain its intent, and require confirmation.

High Stakes & Reversible: These nodes can rely on the Action Audit & Undo pattern. If the AI-powered sales agent moves a lead to a different pipeline, it can do so autonomously as long as it notifies the user and offers an immediate Undo button.

By strictly categorizing nodes this way, we avoid “alert fatigue.” We reserve the high-friction Intent Preview only for the truly irreversible moments, while relying on the Action Audit to maintain speed for everything else.

	Reversible	Irreversible
Low Impact	Type: Auto-Execute UI: Passive Toast / Log Ex: Renaming a file	Type: Confirm UI: Simple Undo option Ex: Archiving an email
High Impact	Type: Review UI: Notification + Review Trail Ex: Sending a draft to a client	Type: Intent preview UI: Modal / Explicit Permission Ex: Deleting a server

Table 1: The impact and reversibility matrix can then be used to map your moments of transparency to design patterns.

Qualitative Validation: “The Wait, Why?” Test #

You can identify potential nodes on a whiteboard, but you must validate them with human behavior. You need to verify whether your map matches the user’s mental model. I use a protocol called the “Wait, Why?” Test.

Ask a user to watch the agent complete a task. Instruct them to speak aloud. Whenever they ask a question, “Wait, why did it do that?” or “Is it stuck?” or “Did it hear me?” — you mark a timestamp.

These questions signal user confusion. The user feels their control slipping away. For example, in a study for a healthcare scheduling assistant, users watched the agent book an appointment. The screen sat static for four seconds. Participants consistently asked, “Is it checking my calendar or the doctor’s?”

Figure 3: The Wait, Why? Protocol. A timeline illustrating how silence creates anxiety. By mapping the specific moment users ask ‘Is it stuck?’, designers can insert transparency exactly when it is needed. 

That question revealed a missing Transparency Moment. The system needed to split that four-second wait into two distinct steps: “Checking your availability” followed by “Syncing with provider schedule.”

This small change reduced users’ expressed levels of anxiety.

Transparency fails when it only describes a system action. The interface must connect the technical process to the user’s specific goal. A screen displaying “Checking your availability” falls flat because it lacks context. The user understands that the AI is looking at a calendar, but they do not know why.

We must pair the action with the outcome. The system needs to split that four-second wait into two distinct steps. First, the interface displays “Checking your calendar to find open times.” Then it updates to “Syncing with the provider’s schedule to secure your appointment.” This grounds the technical process in the user’s actual life.

Consider an AI managing inventory for a local cafe. The system encounters a supply shortage. An interface reading “contacting vendor” or “reviewing options” creates anxiety. The manager wonders if the system is canceling the order or buying an expensive alternative. A better approach is to explain the intended result: “Evaluating alternative suppliers to maintain your Friday delivery schedule.” This tells the user exactly what the AI is trying to achieve.

Operationalizing the Audit 

You have completed the Decision Node Audit and filtered your list through the Impact and Risk Matrix. You now have a list of essential moments for being transparent. Next, you need to create them in the UI. This step requires teamwork across different departments. You can’t design transparency by yourself using a design tool. You need to understand how the system works behind the scenes.

Start with a Logic Review. Meet with your lead system designer. Bring your map of decision nodes. You need to confirm that the system can actually share these states. I often find that the technical system doesn’t reveal the exact state I want to show. The engineer might say the system just returns a general “working” status. You must push for a detailed update. You need the system to send a specific notice when it switches from reading text to checking rules. Without that technical connection, your design is impossible to build.

Next, involve the Content Design team. You have the technical reason for the AI’s action, but you need a clear, human-friendly explanation. Engineers provide the underlying process, but content designers provide the way it’s communicated. Do not write these messages alone. A developer might write “Executing function 402,” which is technically correct but meaningless to the user. A designer might write “Thinking,” which is friendly but too vague. A content strategist finds the right middle ground. They create specific phrases, such as “Scanning for liability risks”, that show the AI is working without confusing the user.

Finally, test the transparency of your messages. Don’t wait until the final product is built to see if the text works. I conduct comparison tests on simple prototypes where the only thing that changes is the status message. For example, I show one group (Group A) a message that says “Verifying identity” and another group (Group B) a message that says “Checking government databases” (these are made-up examples, but you understand the point). Then I ask them which AI feels safer. You’ll often discover that certain words cause worry, while others build trust. You must treat the wording as something you need to test and prove effective.

How This Changes the Design Process

Conducting these audits has the potential to strengthen how a team works together. We stop handing off polished design files. We start using messy prototypes and shared spreadsheets. The core tool becomes a transparency matrix. Engineers and the content designers edit this spreadsheet together. They map the exact technical codes to the words the user will read.

Teams will experience friction during the logic review. Imagine a designer asking the engineer how the AI decides to decline a transaction submitted on an expense report. The engineer might say the backend only outputs a generic status code like “Error: Missing Data”. The designer states that this isn’t actionable information on the screen. The designer negotiates with the engineer to create a specific technical hook. The engineer writes a new rule so the system reports exactly what is missing, such as a missing receipt image.

Content designers act as translators during this phase. A developer might write a technically accurate string like “Calculating confidence threshold for vendor matching.” A content designer translates that string into a phrase that builds trust for a specific outcome. The strategist rewrites it as “Comparing local vendor prices to secure your Friday delivery.” The user understands the action and the result.

The entire cross-functional team sits in on user testing sessions. They watch a real person react to different status messages. Seeing a user panic because the screen says “Executing trade” forces the team to rethink their approach. The engineers and designers align on better wording. They change the text to “Verifying sufficient funds” before buying stock. Testing together guarantees the final interface serves both the system logic and the user’s peace of mind.

It does require time to incorporate these additional activities into the team’s calendar. However, the end result should be a team that communicates more openly, and users who have a better understanding of what their AI-powered tools are doing on their behalf (and why). This integrated approach is a cornerstone of designing truly trustworthy AI experiences.

Trust Is A Design Choice

We often view trust as an emotional byproduct of a good user experience. It is easier to view trust as a mechanical result of predictable communication.

We build trust by showing the right information at the right time. We destroy it by overwhelming the user or hiding the machinery completely.

Start with the Decision Node Audit, particularly for agentic AI tools and products. Find the moments where the system makes a judgment call. Map those moments to the Risk Matrix. If the stakes are high, open the box. Show the work.

In the next article, we will look at how to design these moments: how to write the copy, structure the UI, and handle the inevitable errors when the agent gets it wrong.

Appendix: The Decision Node Audit Checklist

Phase 1: Setup and Mapping

✅ Get the team together: Bring in the product owners, business analysts, designers, key decision-makers, and the engineers who built the AI.

Hint: You need the engineers to explain the actual backend logic. Do not attempt this step alone.

✅ Draw the whole process: Document every step the AI takes, from the user’s first action to the final result.

Hint: A physical whiteboard session often works best for drawing out these initial steps.

Phase 2: Locating the Hidden Logic

✅ Find where things are unclear: Look at the process map for any spot where the AI compares options or inputs that do not have one perfect match.

✅ Identify the best guess steps: For each unclear spot, check if the system uses a confidence score. For example, ask if the system is 85 percent sure. These are the points where the AI makes a final choice.

✅ Examine the choice: For each choice point, figure out the specific internal math or comparison being done. An example is matching a part of a contract to a policy. Another example involves comparing a picture of a broken car to a library of damaged car photos.

Phase 3: Creating the User Experience

✅ Write clear explanations: Create messages for the user that clearly describe the specific internal action happening when the AI makes a choice.

Hint: Ground your messages in concrete reality. If an AI books a meeting with a client at a local cafe, tell the user the system is checking the cafe reservation system.

✅ Update the screen: Put these new, clear explanations into the user interface. Replace vague messages like Reviewing contracts with your specific explanations.

✅ Check for Trust: Make sure the new screen messages give users a simple reason for any wait time or result. This should make them feel confident and trusting.

Hint: Test these messages with actual users to verify they understand the specific outcome being achieved.

The UX Designer’s Nightmare: When “Production-Ready” Becomes A Design Deliverable

 

In a rush to embrace AI, the industry is redefining what it means to be a UX designer, blurring the line between design and engineering. Carrie Webster explores what’s gained, what’s lost, and why designers need to remain the guardians of the user experience.

In early 2026, I noticed that the UX designer’s toolkit seemed to shift overnight. The industry standard “Should designers code?” debate was abruptly settled by the market, not through a consensus of our craft, but through the brute force of job requirements. If you browse LinkedIn today, you’ll notice a stark change: UX roles increasingly demand AI-augmented development, technical orchestration, and production-ready prototyping.

For many, including myself, this is the ultimate design job nightmare. We are being asked to deliver both the “vibe” and the “code” simultaneously, using AI agents to bridge a technical gap that previously took years of computer science knowledge and coding experience to cross. But as the industry rushes to meet these new expectations, they are discovering that AI-generated functional code is not always good code.

The LinkedIn Pressure Cooker: Role Creep In 2026

The job market is sending a clear signal. While traditional graphic design roles are expected to grow by only 3% through 2034, UX, UI, and Product Design roles are projected to grow by 16% over the same period.

However, this growth is increasingly tied to the rise of AI product development, where “design skills” have recently become the #1 most in-demand capability, even ahead of coding and cloud infrastructure. Companies building these platforms are no longer just looking for visual designers; they need professionals who can “translate technical capability into human-centered experiences.”

This creates a high-stakes environment for the UX designer. We are no longer just responsible for the interface; we are expected to understand the technical logic well enough to ensure that complex AI capabilities feel intuitive, safe, and useful for the human on the other side of the screen. Designers are being pushed toward a “design engineer” model, where we must bridge the gap between abstract AI logic and user-facing code.

A recent survey found that 73% of designers now view AI as a primary collaborator rather than just a tool. However, this “collaboration” often looks like “role creep.” Recruiters are often not just looking for someone who understands user empathy and information architecture — they want someone who can also prompt a React component into existence and push it to a repository!

This shift has created a competency gap.

As an experienced senior designer who has spent decades mastering the nuances of cognitive load, accessibility standards, and ethnographic research, I am suddenly finding myself being judged on my ability to debug a CSS Flexbox issue or manage a Git branch.

The nightmare isn’t the technology itself. It’s the reallocation of value.

Businesses are beginning to value the speed of output over the quality of the experience, fundamentally changing what it means to be a “successful” designer in 2026.

“

Tools that allow designers to switch from design to code. (Image source: Figma)

The Competence Trap: Two Job Skill Sets, One Average Result

There is potentially a very dangerous myth circulating in boardrooms that AI makes a designer “equal” to an engineer. This narrative suggests that because an LLM can generate a functional JavaScript event handler, the person prompting it doesn’t need to understand the underlying logic. In reality, attempting to master two disparate, deep fields simultaneously will most likely lead to being averagely competent at both.

The “Averagely Competent” Dilemma #

For a senior UX designer to become a senior-level coder is like asking a master chef to also be a master plumber because “they both work in the kitchen.” You might get the water running, but you won’t know why the pipes are rattling.

• The “cognitive offloading” risk.
  Research shows that while AI can speed up task completion, it often leads to a significant decrease in conceptual mastery. In a controlled study, participants using AI assistance scored 17% lower on comprehension tests than those who coded by hand.
• The debugging gap.
  The largest performance gap between AI-reliant users and hand-coders is in debugging. When a designer uses AI to write code they don’t fully understand, they don’t have the ability to identify when and why it fails.

Using AI tools impedes coding skill formation. (Image source: Anthropic) 

So, if a designer ships an AI-generated component that breaks during a high-traffic event and cannot manually trace the logic, they are no longer an expert. They are now a liability.

The High Cost Of Unoptimised Code 

Any experienced code engineer will tell you that creating code with AI without the right prompt leads to a lot of rework. Because most designers lack the technical foundation to audit the code the AI gives them, they are inadvertently shipping massive amounts of “Quality Debt”.

Common Issues In Designer-Generated AI Code

• The security flaw
  Recent reports indicate that up to 92% of AI-generated codebases contain at least one critical vulnerability. A designer might see a functioning login form, unaware that it has an 86% failure rate in XSS defense, which are the security measures aimed at preventing attackers from injecting malicious scripts into trusted websites.
• The accessibility illusion
  AI often generates “functional” applications that lack semantic integrity. A designer might prompt a “beautiful and functional toggle switch,” but the AI may provide a non-semantic <div> that lacks keyboard focus and screen-reader compatibility, creating Accessibility Debt that is expensive to fix later.
• The performance penalty
  AI-generated code tends to be verbose. AI is linked to 4x more code duplication than human-written code. This verbosity slows down page loads, creates massive CSS files, and negatively impacts SEO. To a business, the task looks “done.” To a user with a slow connection or a screen reader, the site is a nightmare.

Creating More Work, Not Less

The promise of AI was that designers could ship features without bothering the engineers. The reality has been the birth of a “Rework Tax” that is draining engineering resources across the industry.

• Cleaning up
  Organisations are finding that while velocity increases, incidents per Pull Request are also rising by 23.5%. Some engineering teams now spend a significant portion of their week cleaning up “AI slop” delivered by design teams who skipped a rigorous review process.
• The communication gap
  Only 69% of designers feel AI improves the quality of their work, compared to 82% of developers. This gap exists because “code that compiles” is not the same as “code that is maintainable.”

When a designer hands off AI-generated code that ignores a company’s internal naming conventions or management patterns, they aren’t helping the engineer; they are creating a puzzle that someone else has to solve later.

Typical issues that developers face with AI-generated code. (Image source: Netcorp)

The Solution 

We need to move away from the nightmare of the “Solo Full-Stack Designer” and toward a model of designer/coder collaboration.

The ideal reality:

• The Partnership
  Instead of designers trying to be mediocre coders, they should work in a human-AI-human loop. A senior UX designer should work with an engineer to use AI; the designer creates prompts for intent, accessibility, and user flow, while the engineer creates prompts for architecture and performance.
• Design systems as guardrails
  To prevent accessibility debt from spreading at scale, accessible components must be the default in your design system. AI should be used to feed these tokens into your UI, ensuring that even generated code stays within the “source of truth.”

Beyond The Prompt #

The industry is currently in a state of “AI Infatuation,” but the pendulum will eventually swing back toward quality.

The UX designer’s nightmare ends when we stop trying to compete with AI tools at what they do best (generating syntax) and keep our focus on what they cannot do (understanding human complexity).

“

Businesses that prioritise “designer-shipped code” without engineering oversight will eventually face a reckoning of technical debt, security breaches, and accessibility lawsuits. The designers who thrive in 2026 and beyond will be those who refuse to be “prompt operators” and instead position themselves as the guardians of the user experience. This is the perfect outcome for experienced designers and for the industry.

Our value has always been our ability to advocate for the human on the other side of the screen. We must use AI to augment our design thinking, allowing us to test more ideas and iterate faster, but we must never let it replace the specialised engineering expertise that ensures our designs technically work for everyone.

Summary Checklist for UX Designers 

• Work Together.
  Use AI-made code as a starting point to talk with your developers. Don’t use it as a shortcut to avoid working with them. Ask them to help you with prompts for code creation for the best outcomes.
• Understand the “Why”.
  Never submit code you don’t understand. If you can’t explain how the AI-generated logic works, don’t include it in your work.
• Build for Everyone.
  Good design is more than just looks. Use AI to check if your code works for people using screen readers or keyboards, not just to make things look pretty.

Shopify For Everyone!How Brands Use AI: Real-World Examples and Strategies Reference

 

Shopify is good. It is not universal. What follows is for everyone the pitch keeps missing.

Shopify is perfect for you

You can't go to a commerce event in 2026 and avoid the pitch. No, not a Commerce event. The other one. The category, not the company. Stay with me. You can't open LinkedIn. You can't watch a Shopify demo without it landing in the first three slides.

Shopify is perfect for you.

It doesn't matter who "you" are. B2B distributor with company hierarchies and negotiated pricing? Shopify. European DTC brand running B2C and wholesale on the same SKUs? Shopify. Headless team trying to build the agent-native commerce stack? Shopify Hydrogen. Bootstrapped developer with $40 a month to spend? Shopify. A creator selling services, products, and bookings out of one cart? Shopify. Heineken? Apparently not. They picked Medusa.

The pitch never adjusts to the merchant. It adjusts to whoever is sponsoring the lunch.

So let's adjust it.

The pitch is bigger than Shopify

I went looking for a Shopify exec saying "Shopify is for everyone." I didn't find one. Shopify itself is more careful than the pitch its industry creates. Shopify Plus marketing segments by use case (B2B, omnichannel, DTC). Tobi Lütke at Editions 2025 talked about helping the merchants on Shopify do well, not about being right for every merchant on the planet.

The universal pitch comes from somewhere else. It comes from agency partners with quotas. It comes from SEO posts like "Why Shopify Will Dominate eCommerce Growth in 2026," positioning Shopify as the "go-to choice for both global enterprise brands and direct-to-consumer creators" in one breath (Ayatas Infotech, 2026). It comes from posts like "The Future of Shopify: How the Platform Will Transform Online Selling in 2026," framing Shopify as a "Complete Business Operating System" for any merchant alive (Fourfoldtech, 2026).

That's the pitch I'm taking apart. Not Shopify the platform. The industry-default reflex that recommends Shopify before anyone has asked who the merchant is.

The Six Platforms Shopify Forgot To Mention

Shopify is real. $378.4 billion in GMV across 5.6 million active stores (DigitalApplied 2026). Excellent at what it was built for. Nothing here is a hit piece.

But "everyone" is doing a lot of work in the universal pitch.

Stop asking "is Shopify good?" Start asking: who is this merchant, and what does the platform cost them in flexibility, ownership, and fit?

I asked that question across six platforms. Each one wins for a different merchant. Each one has been told Shopify is perfect for them. Each one has a better answer.

I write this for the merchant in the audience who got told Shopify is perfect for them at NRF, ShopTalk, eTail, or some podcast last week and hasn't asked the question since. The merchant deserves a real comparison. The merchant deserves to know there are six other names in this conversation. The platforms deserve to be in it.

I have written about my own paradox before. I built a Shopify app even after years of explaining the platform's limitations, because that is where the customers are (My Shopify Paradox, ACG, July 2025). The paradox is real. The pitch is the problem.

Six because of time and space. The list could go longer (commercetools, Salesforce Commerce Cloud, Spryker, Saleor, Vendure, OroCommerce, PrestaShop, Centra). Each has its merchant. These six are where to start.

Let's start with the one that just changed its name.

1. Commerce (formerly BigCommerce)

The merchant: SaaS without the walled garden, with agentic commerce baked in.

BigCommerce has a great product. Let me say that twice. BigCommerce has a great product. The platform ships an enterprise-grade SaaS that you can extend with Catalyst, Makeswift for visual editing, and Feedonomics for product feeds across Google, Meta, TikTok, and Amazon. Mountain Warehouse just launched a composable storefront on Catalyst with Vercel, Contentful, and Algolia (Commerce press, April 2026). That's a real merchant doing real composable work without leaving the platform.

Catalyst sidesteps a problem I wrote about before (The Headless Trap, ACG, August 2025). The framework is opinionated. The platform is opinionated. The merchant doesn't have to assemble both from scratch.

The rebrand is the problem. In July 2025, BigCommerce announced it was becoming "Commerce" (Wikipedia). The ticker changed from BIGC to CMRC around August 1, 2025. Three product lines (BigCommerce, Feedonomics, Makeswift) now sit under one parent brand. CEO Travis Hess called it "a clear declaration" focused on "agentic commerce" (EcommerceNews EU, 2025). The agentic commerce read is right. The naming is muddled. Calling the company "Commerce" and the product "BigCommerce" might work in the long run. Maybe.

Let's call BigCommerce BigCommerce.

The product earned the rebrand. The rebrand hasn't earned the product yet.

Pro: Open SaaS with real composable hosting and a feed manager (Feedonomics) that the rest of the category copies. Con: The strategic message got diluted in the rename, and merchants are still figuring out what to call what. Real merchant: Mountain Warehouse on Catalyst (April 2026). Agentic readiness: Commerce Companion AI in admin, Feedonomics with Google Cloud Gemini for product enrichment, agent-enabled checkout work in the roadmap. Best for: Mid-market merchants who want SaaS stability and composable flexibility without writing a headless storefront from scratch. Catalyst gives them the framework. Makeswift gives them visual editing on top, so non-developers can ship storefront changes. Feedonomics handles cross-channel feeds across Google, Meta, TikTok, and Amazon. They run multi-channel selling, they want headless without a full engineering team, and they are done with Shopify Plus telling them which composable extensions are allowed.

2. Shopware

The merchant: complex B2B. Companies with hierarchies, sales reps, custom catalogs per customer, quoted pricing, and approval workflows. Shopware wins 54% of the deals it competes for in this category (per Shopware). DTC merchants run on it too, but B2B is the headline.

The time is now for Shopware. You own your data. You don't rent it back from a SaaS company that decides one day to change your fees, your checkout, or your app permissions. You make any change you want, any customization you need, because the license lets you. You get support from a team that picks up the phone.

Then there is the pricing. Shopify charges by volume. Transaction fees on every sale. App store fees that compound. Plus tiers that scale with revenue. The bigger the merchant, the bigger the bill. Shopware caps the platform cost through licensing. The busier the merchant, the better the unit economics. That is not a small thing for a brand doing $20M, $50M, or $200M GMV. When the merchant grows, the merchant keeps the upside.

Then there's the funding story. PayPal first invested in Shopware in February 2022 as part of a $100 million round with Carlyle Group (Shopware press release, 2022). In October 2025, PayPal increased its stake from 11% to roughly 41% by buying Carlyle's shares (EcommerceNews EU, 2025). PayPal is now Shopware's largest external shareholder. That isn't a partnership announcement. That's a payments company putting real ownership behind a platform built for merchants who want B2B, DTC, and ownership in one stack.

The US momentum is the new story. Shopware North America reported 300% year-over-year growth in the first half of 2025 (Shopware press, 2025). Named US client wins included UPPAbaby, Good360, Eagle Crusher, BlueAlly, Noble, and Dynamic Team Sports. New US partnerships landed with Klaviyo, BlueSnap, PayTrace, Webscale, and Liquid Web. Shopware hosted Shoptoberfest in NYC in September 2025 to celebrate the company's 25th anniversary on US soil (PR Newswire, 2025-09-16). Store Leads data showed Shopware net-gained 2,995 merchants from competitive platforms over the prior 90 days (Store Leads, Q1 2026).

Shopware is closing deals and making waves in the US market. The agencies told you Shopify Plus could do B2B. Shopify Plus does company logins. Shopware does company hierarchies, native quoting, sales rep tools, and custom catalogs per customer. That's B2B. The other thing is a feature flag.

Pro: Native B2B depth (54% win rate per Shopware), licensing model that doesn't tax growth, US momentum backed by 41% PayPal ownership. Con: The brand is still earning US recognition, which means agencies still default to Shopify Plus on first reference. Real merchant: Eagle Crusher (heavy equipment B2B) and UPPAbaby (premium DTC), both US. Agentic readiness: Shopware AI Copilot for product data, content, and customer service. Best for: Mid-market and enterprise merchants running complex B2B. Company hierarchies, sales rep accounts, custom catalogs per customer, quoted pricing, approval workflows. Shopware closes 54% of the deals it competes for in this category (per Shopware). DTC merchants run on it too, but B2B is the headline. They want ownership over rent, customization their lawyer can approve, a team that picks up the phone, and a pricing model that doesn't punish them for growing. Increasingly US-based: 300% YoY North American growth, named wins like Eagle Crusher and UPPAbaby.

3. Wix

The merchant: the creator whose storefront IS the brand presence.

Wix is the new up-and-comer, and the AI tools they are adding are fantastic. You get world-class content and commerce in one easy-to-use package.

We underestimate Wix because it sells to people we don't talk to at conferences. The creator running services, products, and bookings doesn't need Plus, doesn't want headless, and has been told for a decade that Shopify is the answer to a question they never asked. Wix shipped one of the most credible AI site builders in the category. The Wix AI Site Generator writes product descriptions, generates images, designs layouts, fills in SEO and meta tags, and runs your ad copy (EasyApps comparison, 2026). Inside the same dashboard. Without an app store tax.

The thing Wix gets right is the merchant nobody else builds for: the brand whose content and commerce are the same business. Bookings, services, products, blog, email, all in one cart, all in one editor. Shopify will sell you Plus to bolt that together. Wix ships it as the default. 1,000 product variants per item versus Shopify's 100. 6+ option sets versus Shopify's 3. 900-plus templates with full drag-and-drop (EasyApps 2026). Built-in Semrush integration and ad management without paying for a higher tier.

For the merchant whose audience IS the storefront, that isn't a feature gap. That's a category.

I made this case before (Don't Underestimate Wix Commerce, ACG, October 2025). The case has only gotten stronger.

Pro: Native bookings, services, and products in one cart with AI tooling baked into the editor. Con: Less credible the higher you go in catalog complexity and headless ambition. Real merchant: Wix's strength is in the long tail of creator and service brands rather than headline DTC names, which is itself part of the story. Agentic readiness: Wix AI Site Generator handles content, layout, SEO, and ad creative end-to-end. Best for: Creators, service-led brands, and small businesses where the storefront IS the brand presence. Yoga studios. Photographers. Coaches. Boutique consultancies selling services, products, and bookings in one cart. They want AI to write product descriptions, design layouts, and run their ad copy without paying $2,500 a month for Shopify Plus. They are not building headless. They want one editor and one tool.

4. Hyvä Commerce on Mage-OS

The merchant: done renting their stack.

Magento. Adobe. Let's face it. Adobe does not care about Magento. They see it as a threat. Hello, Magento IS Adobe. They should be gaining sites TO Adobe FROM Magento. It's the perfect funnel. Instead, Adobe sees Magento as competition.

The lack of focus on commerce shows up in poor support, poor performance, and no real roadmap. When I say no real roadmap, I challenge anyone from Adobe to show me their commerce roadmap. No feature ever. No feature planning. Nothing new. Did I mention nothing new?

I got to a lot of Magento conferences. Same slides. No new commerce features. No new commerce features. No new commerce features.

I will not pull punches on Adobe.

One warning before we leave Adobe. The European Magento community sees Hyvä shipping, sees Mage-OS shipping, and assumes the US Magento ecosystem looks the same. It does not. Adobe stopped marketing Magento in the US. Are they signing new US agencies? I doubt it. The US Magento community has been left to fend for itself while Adobe's attention went to AEM and AEP. That's not a Hyvä problem. That's not a Mage-OS problem. That's an Adobe problem. And the US merchant pays for it.

Hyvä is going gangbusters. New products coming out all the time, pushing performance, building everything Adobe Commerce could be but isn't. Hyvä Themes replaced Magento's Knockout.js with Alpine.js and Tailwind, and agencies report 30 to 50% faster builds (Hyvä 2025 product update). 6,400 live stores already run Hyvä (Hyvä 2025 product update). On November 10, 2025, Hyvä Themes went open source under OSL3 and AFL3, announced at Meet Magento Netherlands (iOvista, 2025-11-10). Hyvä Commerce launched the same year as a separate product built to extend Magento Open Source for ops, scalability, and merchant experience (Fluid Commerce, 2025).

Mage-OS is the foundation. A community-governed, upstream-compatible fork of Magento Open Source, run by the independent Mage-OS Association rather than the Adobe-controlled Magento Association (Mage-OS, ongoing). The fork exists because Adobe stopped investing. Adobe Commerce starts at roughly $22,000 per year (Web-vision, 2025). Mage-OS is free.

The merchant who picks Hyvä on Mage-OS is done renting. They want code ownership, performance, and a community that ships. They got tired of waiting for Adobe to come back. So they built without Adobe.

Pro: Open-source ownership, fastest frontend in the category, governed by a community that ships in the open. Con: Requires a development team. This isn't a "set it up in 30 minutes" platform. Real merchant: 6,400+ live Hyvä-powered stores across the Magento ecosystem. Agentic readiness: Open architecture means any agentic layer can be wired in. Nothing is gated by a vendor. Best for: Merchants who picked Magento years ago, watched Adobe stop shipping commerce features, and decided to keep their stack instead of starting over. They want code ownership, not a SaaS subscription. They want the fastest frontend in the category. They want a community-governed platform where the roadmap is in the open. They have a development team or a partner agency who can run it.

5. MedusaJS

The merchant: a team building commerce around the agent, not bolting an agent onto commerce.

I really like what Medusa is doing. The homepage tagline tells you the whole story: "A Commerce Platform for Developers and Agents" (medusajs.com). Not a marketing line bolted onto a SaaS product. The architecture itself was rebuilt around how developers and AI agents work.

Bloom lets you chat to build. Agent Skills are baked into the development experience. One Medusa case study reports 80% cost savings on an AI-powered email-to-order workflow (medusajs.com). That isn't an integration. That's the product.

The proof is on the homepage. Heineken. EightSleep. Mitsubishi Motors. None of those brands picked Medusa because it's free or easy. They picked it because their teams wanted commerce built around how their teams already work. With $29 entry pricing and no GMV tax, the economics aren't the story either. The story is the architecture and the team behind it.

I went deeper on Medusa in (A Look at Medusa Commerce, ACG, December 2025). What stood out then was the architecture. What stands out now is the merchant proof.

Every European platform trying to enter the US market, including Medusa, hits the same wall. Shopify is the gorilla in the room. Shopware is climbing. 300% year-over-year growth, named US wins, real partnerships. Medusa is earlier in that climb. They need boots on the ground in the US. They need US advocates willing to talk about what they're doing well in the markets where Shopify is the default answer. The platforms are good. The marketing fight against Shopify in the US is the harder problem.

The merchant who picks Medusa is a developer-led team that read "agentic commerce" and asked what commerce could look like if you started from the agent, instead of asking how you bolt an agent onto Shopify.

Pro: Architecture built around developers and agents, with named brand proof on the homepage. Con: The US market presence is still building. The community is smaller than Shopify's app ecosystem. Real merchant: Heineken, EightSleep, Mitsubishi Motors (medusajs.com). Agentic readiness: This is the platform where "agentic" isn't a marketing layer. It's the design center. Best for: Developer-led DTC brands who read "agentic commerce" as an architecture decision, not a marketing slide. They have a TypeScript team. They want an open-source platform that ships fast and has Heineken on the homepage. They want commerce APIs an agent can call directly, not a proprietary checkout SDK. They want $29-a-month entry pricing with no GMV tax. They are building the next-generation stack and they want a platform doing the same.

6. WooCommerce

The merchant: the audience-first brand where content built the demand.

WooCommerce is the most-deployed commerce platform on the open web. 4.7 million active stores. 18 to 21% global share by share-of-websites (DigitalApplied 2026). And it's the platform Shopify ignores hardest. Why? Three reasons that matter.

First, the migration goes both ways. 9,195 stores moved from WooCommerce to Shopify in the last measurement period. 7,566 went the other direction, Shopify to WooCommerce (DigitalApplied 2026). That's not a funnel into Shopify. That's a swap. Shopify doesn't draw attention to a flow that runs both ways.

Second, the WooCommerce merchant isn't the Shopify merchant. Shopify sells "store first, content later." The Woo merchant built the audience first and added the cart when the audience was ready to buy. The sales motion doesn't translate. The pitch doesn't land. Shopify's marketing budget can't reach a merchant whose store is a checkout button on a blog they've been writing for ten years.

Third, the plugin moat is unbeatable. 60,000-plus WordPress plugins, any niche use case has a Woo extension that someone built and maintains (Salesforce 2026, generally accepted WordPress.org plugin directory size). Shopify's app store can't match that breadth, and the breadth IS the lock-in. Once a Woo store has fifteen plugins solving fifteen specific problems, it isn't migrating anywhere.

WooCommerce is open source. Free. Bolts onto WordPress. You can run it on WordPress.com, on any managed WordPress host (Pressable, Kinsta, WP Engine, Hostinger, Bluehost, Cloudways), or on your own infrastructure. The optionality is the point. Shopify charges by the seat. WooCommerce charges by the choice you already made when you picked WordPress.

The merchant who picks WooCommerce is the audience-first brand. The publisher, the creator, the ten-year blogger, the membership site, the community. Their content built the demand. The cart just collects on it.

Pro: Open-source, biggest plugin ecosystem on the web, owned by Automattic (not running out of runway). Con: You own the hosting, security, and maintenance choices. That's freedom and that's responsibility. Real merchant: 4.7 million stores running it, including the bidirectional migration crowd. Agentic readiness: WordPress's plugin model means any AI agent layer can plug in. The ecosystem is moving on this faster than the headlines suggest. Best for: Audience-first brands. The publisher who built ten years of newsletter readers and wants to sell them something. The blogger whose audience is bigger than their store. The membership site adding paid courses. The community building a product around their already-loyal followers. They are not picking commerce-first. They are picking content-first, and the cart is the natural extension.

So what?

The pitch is broken. The platforms aren't.

Shopify is good. Shopify is not universal. Anyone selling you "Shopify is perfect for you" is selling Shopify. They are not solving for you. The right question for any merchant is simple. Who is this merchant? What does the platform cost them in flexibility, ownership, and fit?

If you're a B2B distributor with company hierarchies, the answer is Shopware or Adobe Commerce or Hyvä on Mage-OS, depending on whether you want SaaS, enterprise rental, or ownership.

If you're a creator running services and products in one cart, the answer is Wix.

If you're a developer-led DTC brand building the agent-native commerce stack, the answer is Medusa.

If you're a publisher whose audience built the demand, the answer is WooCommerce.

If you're a mid-market merchant who wants SaaS without the walled garden, the answer is BigCommerce. Sorry. Commerce. The product is BigCommerce. The company is Commerce. We'll figure that one out.

If you're done renting your stack, the answer is Hyvä on Mage-OS.

The platform is downstream of the merchant. Pick the merchant first. Pick the platform second.

The next time you hear "Shopify is perfect for you" at a panel, ask the speaker who they're selling to. If they can't answer that without saying "everyone," they're not selling you. They're selling the sponsor.

Question for you

Which of the six would you build on next, and what told you Shopify wasn't the right pick?

I read every comment.

One more question to sit with.

Is the world really better with only one commerce platform?

---

More businesses are discovering that AI’s value truly emerges when it augments human creativity and capability rather than completely replacing it.
Reference: https://www.shopify.com/blog/how-brands-use-ai?Artificial intelligence has moved from promise to practice in record time—and business leaders are racing to harness it. McKinsey reports that 92% of companies plan to increase their AI investments over the next three years. At the same time, early adopters are already seeing meaningful improvements: Among small businesses currently using AI, 80% report increased efficiency, and nearly half say that AI has improved their data-driven decision-making, according to Goldman Sachs.

Yet, AI isn’t a magic bullet. It takes careful scoping and thoughtful implementation to deliver value. AI isn’t a replacement for the creativity, judgment, or intuition that small businesses rely on. Instead, it’s expanding what small teams can accomplish: According to a 2025 Shopify survey, 69% of business owners who use AI tools do so to generate content. Other popular use cases include helping with data analysis and insights (32%), improving customer service quality (29%), and assisting with product development (23%).

More businesses are discovering that AI’s value truly emerges when it augments human creativity and capability rather than completely replacing it. These are the ways savvy businesses are putting AI to work—and where they’re finding the most success.
Reference: https://www.shopify.com/blog/how-brands-use-ai?Democratizing data science for smarter campaigns

What once required focus groups, surveys, and weeks of analysis can now happen in a matter of minutes with AI. Small businesses are increasingly using AI for market research tasks like analyzing customer reviews, social conversations, and search behavior, uncovering emerging needs before competitors can respond.

Jones Road Beauty uses tools like OpenAI’s Deep Research to analyze thousands of product reviews, Reddit threads, and YouTube comments. From that analysis, the clean-beauty brand’s team identified five real-world personas—such as busy parents and frequent travelers. Those insights informed its Just Enough tinted moisturizer campaign, helping the team refine messaging, select appropriate models, and shape the overall creative direction.

AI-powered analysis isn’t just speeding up data analysis—it’s making it available to anyone at the company. Wallet and accessories brand Ridge is using AI to remove internal bottlenecks that used to slow data-driven decision-making. “We have a data warehouse and all these Shopify reports,” says Ridge CEO Sean Frank. “Instead of doing anything manually, I can take a screenshot, drop it into ChatGPT, and it runs the analysis for me. My entire team can operate like data scientists.” Rather than waiting hours or days for a specialist to crunch numbers, anyone on the team can pull their own insights instantly.

Your 24/7 Shopify expert is here

Do data analysis without leaving your admin with Sidekick. Learn how your AI assistant makes it easier to start, run and grow your business on Shopify.
Meet Sidekick

These examples illustrate a broader shift: AI is giving small teams the analytical horsepower of larger organizations. By lowering the barrier to data analysis, brands can move faster, experiment more often, and build campaigns rooted in what customers actually think and do.
Building personalized products

For small businesses with limited engineering resources, launching a new product can be costly and time-consuming. AI is shifting that calculus. By accelerating research, content generation, and user-testing cycles, AI enables teams to bring new digital offerings to market with unprecedented speed. In many cases, it isn’t just accelerating development, but making entirely new categories of personalized, adaptive products possible.

Get your free product development worksheet

Create a product that meets your customers’ needs with our easy-to-follow, 7-step product development worksheet.
Learn more

Loftie, a wellness company that designs sleep products, used AI to develop and launch the Loftie Rest app, a digital companion to its signature alarm clock. The app broadened Loftie’s reach and unlocked a new revenue stream, creating a subscription business from the ground up that now has roughly 15,000 members. “We wouldn’t have released this product without AI,” founder and CEO Matthew Hassett says. “It was the initial seed of what our subscription app became.”

Personalized content is the backbone of the Rest app, beginning with Storymaker, which generates tailored bedtime stories using a brief survey and adjustable voice profiles powered by OpenAI and Eleven Labs. Extending personalization even further, Loftie’s Night School feature analyzes correlations between users’ Apple Health data, screen time habits, alarm settings, and self-reported sleep quality. When patterns emerge—like midnight scrolling leading to poor sleep—the tool recommends habit changes or prompts users to block distracting apps. “We use AI to look at patterns and make proactive suggestions to help you ditch your phone at night,” Matthew says.

At every stage, Loftie pairs AI insights with human-created content, from educational modules to meditation flows. AI determines what a user needs, while humans help craft what is delivered. The result is a digital product that continuously adapts while maintaining a distinctly human tone, something that would have been prohibitively complex to build without AI.
Scaling ad creation and testing

Scaling creative output is becoming an essential part of a strong paid advertising strategy. For success, brands need an increasing number of ad variations—often more than a creative team can realistically produce on its own.

Ridge is using AI to close that gap. It created a custom GPT trained on its best-performing ads, then connected it to automation tools that generate hundreds of new static assets each day. “We’ve built a static ad factory,” says Sean. “I can get 500 ads a day—no hands on keyboards.” 

These assets flow into a shared drive for review, but most won’t make it into rotation. And that’s OK; the point is volume. “Out of those 500, 450 are horrible,” Sean notes. “But the top 10% are between five out of 10 and seven out of 10. They’ll get spend behind them.” The brand plans to extend this process to video next, generating more hooks and variations for testing.

AI is not replacing Ridge’s creative team. The company’s highest-performing ads still come from the human design team, which consistently produces 10-out-of-10 winners. AI just enables more concepts, more iterations, and more opportunities for platforms like Facebook to match the right ad to the right person at the right time.

Reach customers everywhere they are with Shopify

Shopify comes with powerful tools that help you promote and sell products on Facebook, Instagram, TikTok, Google, and YouTube from one back office. Make sales on multiple channels and manage everything from Shopify.
Explore Shopify’s sales channels

“The future of advertising is just shots on goal,” explains Sean. “What you see and like is going to be totally different from what I see and like.” By pairing human-crafted assets with high-volume AI-generated variations, Ridge can scale experimentation far beyond what manual efforts would allow—turning its paid strategy into a continuous, data-driven loop of testing and refinement. 
Improving customer service

Early AI tools like chatbots and interactive voice response (IVR) were a natural fit for repetitive use cases (like “Where’s my order?” and “What are your hours?”). This makes customer service one of the most mature applications of AI in small businesses. However, the stakes of balancing human and machine intervention remain high. A 2024 study from Acquire Intelligence found that just one bad AI-assisted support experience would make 70% of consumers consider taking their business elsewhere.

At Loftie, AI agents now answer over half of incoming support emails. “It’s difficult to standardize responses across human agents—AI can be much more reliable,” Matthew says. “It’s answered the same question 1,000 times before.” The team also uses AI to surface trends from what Matthew calls a “graveyard of data,” turning thousands of customer interactions into insights that inform product and experience improvements. “I’m honestly surprised when brands are reticent to adopt AI for customer service,” he notes.

Ridge has seen similar benefits. “Customer service is a super easy use case,” Sean explains. “Around 60% of our tickets are being answered by AI.” The company has also seen a 10% to 20% lift in customer satisfaction scores over human-only workflows. “Customers love talking to the AI,” he adds. “It’s faster, quicker, more accurate.”

These improvements are driven by a shift from rule-based chatbots to agentic AI—tools that can understand intent, reference past interactions, access customer data, and take simple actions like processing refunds or replacing items. Once limited to large enterprises, agentic AI is accessible today via tools like Zendesk and HubSpot.

When implemented thoughtfully—and understanding when to escalate emotional issues and complex problems to a human agent—AI expands what teams can handle without sacrificing quality. Routine questions are resolved quickly and consistently, and human agents can spend more time on the conversations that matter most.

As AI continues to evolve, the opportunity for small businesses will come from this kind of selective adoption: using AI where it elevates human capabilities and keeping people at the center of the work that defines the brand.