Skip to Content

Stephen Quick

16 posts

Posts by Stephen Quick

Stop Hiding Behind the Acronyms

Every industry has its own language. That’s fine. Specialized work needs specialized words sometimes.

But there’s a difference between using shorthand because it’s efficient and using it because it’s become a habit nobody questions anymore. A habit that ends up putting distance between people who should be on the same page.

Marketing does this. Tech does this. And if you’ve been on the receiving end of either, you’ve felt it. That moment where someone rattles off a string of letters and you nod along because you don’t want to be the one who asks what it means. We’ve all been there.

I’ve spent over 25 years building websites and digital marketing for home service contractors. HVAC companies, plumbers, electricians, roofers. People who do real work with their hands. And one of the most consistent problems I’ve seen across this entire industry is the gap between what people say they’re doing and what’s actually happening. Abbreviations make that gap wider than it needs to be.

The Marketing Version

You’re a contractor. You’ve been running your business for fifteen years. You’re great at what you do. But you need more leads, so you hire a marketing agency.

First month goes by. They send you a report. It’s a PDF, maybe a dashboard link. It’s full of KPIs and CTRs and CPAs and ROAS and MQLs. There are colored charts. Trend lines. A section about “organic impressions” and another about “engagement metrics.” Everything looks very professional.

You read it twice. You still don’t know if it’s working.

That’s a communication problem. And it happens all the time.

Here’s what’s going on. When someone tells you your CPC is down 12% but your CPA is up, what are they really saying? They’re saying people are clicking your ads for less money, but it’s costing you more to actually get a customer. That’s a problem. That should be a conversation. But wrapped in abbreviations, it sounds like a mixed bag instead of a red flag. It sounds like progress with a caveat, not a strategy that needs fixing.

I’ve been in digital marketing my entire career. I’ve seen reports that lean on acronyms so heavily that the actual performance gets lost in the noise. Not because anyone is trying to be misleading. But because the language we use in this industry has drifted so far from plain English that even the people writing the reports don’t always stop to think about whether the person reading it can follow along.

An agency might describe their work as running PPC campaigns optimized for ROAS with A/B testing across multiple CTA variants to improve CVR. That sounds like a lot of work. It sounds expensive. But what they actually said is: “We’re running ads and testing which button gets more clicks.” That’s it. That’s the whole thing. The work isn’t any less valuable in plain language. It’s just easier to understand.

Here’s what a contractor actually needs to know: Did the phone ring? Did those calls turn into jobs? Did we make money? Are we doing better this month than last month? What are you changing to improve it?

You don’t need a glossary for that. You need a partner who respects you enough to talk straight.

Tech Does the Exact Same Thing

Developers are just as deep in it. Maybe deeper.

You sit in a meeting and someone says they’re building a microservices architecture with a CI/CD pipeline, containerized with K8s, running a LAMP stack but migrating to MEAN with SSR and ISR.

You nod. You leave the meeting. You have no idea what just happened.

And here’s the thing. Half the time, the people saying it couldn’t always tell you why they chose that stack over something simpler. They know the acronyms. They can define them if you put them on the spot. But the decision wasn’t always driven by the project’s needs. It was driven by what’s trending. What the last conference talk recommended. What everyone else is talking about.

I’ve been writing code since 1999. PHP, HTML, JavaScript. The fundamentals. The stuff that actually renders the page in someone’s browser. And I can tell you that a lot of the complexity people bolt onto projects isn’t solving a problem. It’s just complexity for the sake of it.

A website that loads fast, looks clean, and converts visitors into customers doesn’t need twelve layers of abstraction. It needs someone who understands the basics and builds with intention. A solid LAMP stack, clean code, and smart architecture will outperform an over-engineered mess every single time. Not because it’s fancier. Because it works. Because someone can maintain it. Because when something breaks at 2 AM, you don’t need a team of six specialists to figure out which container went down.

Just Be Honest

I know that sounds like something you’d read on a motivational poster. But I mean it in a very specific way.

When you’re working with a client, you have two choices. You can talk to them in a way that makes you sound smart. Or you can talk to them in a way that makes them feel smart. One of those builds trust. The other one builds dependency.

I’ve been in this business long enough to know which one works. The agencies that last, the developers that keep clients for a decade, the companies that grow through referrals instead of ad spend, they all have one thing in common. They talk straight. They communicate in plain language when things are going well, and they do the same when things aren’t.

Honesty is harder than jargon. It takes more effort. If an SEO campaign isn’t producing results yet, it’s easier to send a report full of acronyms that show movement than it is to pick up the phone and say, “Here’s where we are, here’s why it’s taking longer than we expected, and here’s what we’re doing about it.” But that phone call is worth more than a hundred dashboards. Because after that conversation, the client trusts you. They know you’re paying attention. They know what’s going on.

The same goes for tech. If a build is behind schedule, don’t bury it in a status update full of technical shorthand. Say it plain. “We hit a problem. Here’s what it is. Here’s how we’re fixing it. Here’s the new timeline.” That’s it. No acronyms needed.

People can handle the truth. What they can’t handle is the feeling that they’re not really in the loop. And abbreviations, even when nobody means for them to, can create exactly that feeling.

Start With the Goal, Not the Method

Here’s where I think a lot of agencies and developers go wrong. They lead with how they do things instead of why.

A contractor doesn’t call a marketing agency because they want a LAMP stack. They call because they want the phone to ring. They want more jobs on the schedule. They want to grow their business. That’s the goal. Everything else is in service of that goal.

But somewhere along the way, our industry started leading with the method. Proposals are full of technology descriptions and process breakdowns and platform names. The goal gets buried under the approach. And the client ends up evaluating things they don’t understand instead of measuring things they care about.

I think about this a lot. The best first conversations I’ve had with clients aren’t about what’s going to be built. They’re about what the client is trying to accomplish. How many jobs do you want on the books each month? What kind of jobs? What’s your service area? Where are you losing customers right now? What does growth look like for you in two years?

Those are goal conversations. And once you’ve had them, the technology part gets a lot simpler. Because now every decision has a reason behind it. You’re building it this way because it gets the client closer to that number. You’re running this campaign because it targets the customers they actually want. No abbreviations necessary. Just a clear line from the work to why it matters for the business.

When you flip it around and lead with the method, you lose people. You lose them in the first meeting. And then you spend the rest of the engagement trying to justify the work with metrics they don’t understand instead of results they can feel.

How to Actually Communicate

I’ve been managing projects and leading teams for a long time. And the single biggest lesson I’ve learned about communication is this: the person listening gets to decide if you were clear. Not you.

You can explain something perfectly in your own head. You can use all the right terms. You can be technically accurate. And the person on the other end can still walk away confused. If that happens, you didn’t communicate. You just talked.

Good communication in this industry means meeting people where they are. If you’re talking to an HVAC contractor, talk about calls and jobs and revenue. If you’re talking to a developer, sure, use the shorthand. Context matters. But when in doubt, go simpler. Nobody ever lost a client because they were too easy to understand.

Here’s what I’ve found works. Start with the outcome. “Here’s what we’re trying to do.” Then explain the approach in plain language. “Here’s how we’re going to get there.” Then set expectations. “Here’s what you’ll see along the way, and here’s how long it should take.” Then check in. “Does that make sense? Do you have questions?”

That’s a conversation. That’s a partnership. There are zero acronyms in that framework and it works for every single client interaction I’ve ever had.

The other piece of this is listening. A lot of people in marketing and tech are so focused on sounding knowledgeable that they forget to listen. Your client is telling you what they need. Usually in plain language. Usually in very clear terms. “I need more calls.” “My website looks outdated.” “I’m losing customers to the company down the road.” Those are the goals. Your job is to hear them, confirm them, and then go solve them. Not to translate them into acronyms and sell them back.

If a client has to ask what something means, that’s a signal. It means the communication needs to be better. The work might be great. But if the client can’t tell, it doesn’t matter.

Why This Happens

It’s the same reason in both industries. Abbreviations create distance between the person doing the work and the person paying for it.

Most of the time, it’s not intentional. It’s just what happens when people spend all day talking to others in their field. You forget that the rest of the world doesn’t speak the same language. Acronyms become automatic. You stop thinking about whether the person across the table knows what REST API means because everyone you talked to this week knew what it meant.

Over time, it becomes the default. People use shorthand without asking whether their audience follows. The language itself becomes a barrier. And nobody stops to question it because it’s just how the industry communicates.

But the result is the same whether it’s intentional or not. The person writing the check doesn’t fully understand what they’re getting. And that’s a problem worth solving.

It’s Worse Now With AI

I have to say it. AI has added a whole new layer to this.

Now you’ve got marketers throwing around acronyms like LLM, NLP, RAG, and GPT in their pitches. “We’re using AI-powered NLP to optimize your content strategy with RAG-based insights.” That sounds incredible. It sounds like the future just showed up to your marketing meeting.

But what does it actually mean? Sometimes it means they’re using ChatGPT to write your blog posts. That’s it. They’re typing a prompt into a chatbot and copying the output onto your website. Which is fine if that’s what you agreed to and what you’re paying for. But it’s not what “AI-powered NLP content optimization” sounds like. It sounds like a million-dollar operation. It’s a ten-dollar-a-month subscription.

On the tech side, it’s the same story. AI can generate code faster than ever. But someone still has to understand what got built. And the abbreviations around AI tools and frameworks are multiplying faster than anyone can keep up. The terminology is outpacing the understanding, and that gap creates confusion for everyone involved.

Writing code was never the bottleneck. The real skill has always been comprehension. Building mental models. Understanding how systems connect. Knowing what breaks when something changes. AI didn’t make that skill less important. It made it essential. And abbreviations don’t help anyone develop that understanding. They just paper over the gap.

They Don’t Know the Terms. They Know the Work.

Here’s something I think a lot of people in marketing and tech forget. Your clients aren’t stupid. They’re just in a different field.

A contractor who’s been running an HVAC business for twenty years understands more about customer acquisition than most marketers will ever learn. They know what makes a homeowner pick up the phone. They know what builds trust in a service call. They know how word of mouth works, how reputation works, how showing up on time and doing clean work turns one job into ten. They understand the technique. They live it every day.

And let’s be real about something. I don’t know their business the way they do. Not even close. I’ve worked with HVAC contractors for over two decades and I still couldn’t walk into a mechanical room and tell you which blower goes with which system. I couldn’t look at a compressor and diagnose what’s wrong with it. I couldn’t tell you the difference between a two-stage furnace and a modulating furnace off the top of my head the way a tech who’s been in the field for ten years can. I don’t know the refrigerant pressures. I don’t know the ductwork calculations. I don’t know which manufacturer’s parts are reliable and which ones fail after two seasons.

They do. That’s their world. They’ve spent years, sometimes decades, mastering it. They went through training, earned certifications, worked under guys who taught them the craft. They can walk into a house and listen to an air handler for five seconds and know what’s wrong. That’s expertise. Real expertise.

So when someone from marketing or tech walks into a room and starts rattling off acronyms to a contractor, think about what that looks like from the other side. Here’s a person who couldn’t change a capacitor talking about AI-driven programmatic SEM. The contractor lives in a world where you either know what you’re doing or you don’t. Where the work speaks for itself. Where a system either heats the house or it doesn’t. There’s no jargon that can cover up a bad install.

That’s the standard we should hold ourselves to. The same clarity. The same accountability. Results you can point to and explain in plain language.

What they don’t know is the terminology. They don’t know that what they’ve been doing with their Google Business Profile is called “local SEO.” They don’t know that the reason their competitor shows up first in search results has to do with backlinks and domain authority. They don’t know that the email they send after every job is technically an “automated post-service nurture sequence.”

But they know it works. They’ve been doing it. They just didn’t have the vocabulary.

And that’s where we come in. Not to talk over their heads. Our job is to meet them where they are and teach them. Let them learn. Give them the understanding, not just the acronyms.

When you sit down with a contractor and explain what’s happening with their website, you don’t need to start with the technology. Start with what they already know. “You know how when someone searches for ‘AC repair near me,’ you want your company to show up first? Here’s what determines that. Here’s what’s being done to make it happen. Here’s how you’ll know it’s working.” That’s teaching. That’s bringing someone in instead of leaving them on the outside.

And you know what happens when you teach a client instead of talking past them? They become better partners. They start asking sharper questions. They notice things on their own. They send you ideas. They understand the reports because someone took the time to walk them through what the numbers actually mean.

I’ve had contractors come back months into a project and say things like, “I think our bounce rate is high on the service page. Can we look at that?” That’s a client who learned something. That’s a client who’s engaged. That didn’t happen because someone threw jargon at them. It happened because someone took the time to explain what bounce rate means and why it matters for their business.

The opposite approach, the one where the client stays in the dark and the abbreviations do the talking, that creates dependence. Not partnership. The client doesn’t learn anything. They just write checks and hope it’s working. And when they eventually move on, they’re no better off than when they started. They still don’t understand what was done for them. They can’t evaluate the next agency any better than they evaluated the last one.

The trades have always been about learning by doing. An apprentice works alongside a journeyman. They watch. They ask questions. They try things. They make mistakes. Eventually they understand the craft. That’s how knowledge gets passed down.

We should be doing the same thing with our clients. Sharing the knowledge. Teaching the technique. Letting people learn. That’s how you build relationships that last. That’s how you build a business that means something.

What Contractors Should Ask

Since most of the people I work with are contractors and home service professionals, let me be specific.

If your marketing agency sends you a report full of abbreviations, ask them to walk you through it. Every line. Not because you’re not smart enough to figure it out. Because clear communication is part of the job. And if they can’t explain what they’re doing in plain language, that’s worth paying attention to.

Here are some questions that cut right through the acronyms:

How many calls did we get this month? How many of those turned into booked jobs? How much did we spend to get each of those jobs? Is that number going up or down? What are you changing next month and why?

That’s it. Those five questions will tell you more about your marketing than any dashboard full of three-letter metrics ever will.

On the tech side, if someone is building you a website or an app, ask the same kinds of questions. What does it do? Why did you build it this way instead of a simpler way? What happens when something breaks? Can I update it myself, or do I need to call you every time? How long will this last before it needs to be rebuilt?

If the answers come back in plain English, you found a good partner. If the answers come back in more abbreviations, keep asking questions until they do.

What I Think We Should Do Instead

Talk to people like people.

If you’re a marketer, tell your client: “More people saw your ad this month, but fewer of them called. Here’s what we’re changing and why we think it’ll work.” That’s a conversation. That’s useful. That builds trust.

If you’re a developer, tell your team lead: “We’re going to build the site so it loads faster and is easier to update without breaking things.” You don’t need to say “headless CMS with static site generation and edge caching.” Not unless they ask. And if they do ask, explain what those things mean. Don’t just define them. Explain why they matter for this project.

If you’re writing a proposal, read it out loud. If you wouldn’t say it to someone at a barbecue, rewrite it. Your proposals should sound like a person talking, not a textbook.

If you’re setting goals with a client, put them in writing. In plain language. “We want to increase your monthly calls by 20% over the next six months.” That’s a goal everyone can measure. Everyone can understand it. And when you check in next month, there’s no confusion. Either the number went up or it didn’t.

The best work I’ve done in 25 years has always been the simplest to explain. If I can’t tell a contractor what I built and why it matters in plain English, I didn’t do my job. That’s the standard. That should be everyone’s standard.

The Real Test

Here’s how you know if someone’s using abbreviations to be efficient or if the language is getting in the way.

Ask them to explain it without the acronym.

If they can, and it still makes sense, and the work still sounds valuable once you strip away the jargon, you’re in good hands. That person knows what they’re doing and they’re using shorthand because it saves time, not because it fills space.

If they stumble, or if the explanation sounds a lot less impressive in plain language, pay attention to that. That gap between the jargon and the reality is where confusion lives. It’s where projects go sideways. It’s where trust starts to erode.

I’ve been doing this for over 25 years. I’ve watched the acronyms multiply. Every year there are more of them. And the lesson is always the same.

Keep it simple. Make it look beautiful. Have it work. And if someone can’t explain what they’re doing for you without a decoder ring, keep asking until they can.

I Found My First Website on a Zip Disk. It Made Me Think About Everything That's Changed.

I Found My First Website on a Zip Disk. It Made Me Think About Everything That's Changed.

Today I found my first website on a Zip disk.

Well, probably. I can't actually open it.

We're in the middle of a move right now. Boxes everywhere. That phase where you're pulling things out of closets and drawers that haven't been touched in years. And buried in one of those boxes was a Zip disk from my Champlain College days. Labeled in my handwriting.

This thing almost certainly has my final project on it. My first real website. Built in Dreamweaver with image maps and tables, because that's how we did it in 1999.

And I have no way to see it.

No drive. No adapter. Just a plastic square holding a snapshot of who I was twenty-six years ago when I was just figuring all of this out.

I stood there holding it for a while. Longer than I should have. Moving makes you do that. Every box is a decision about what still matters. But this one hit different. Because the thing on that disk? I'm still doing it. I never stopped.

Twenty-six years. Same craft. Completely different world.

That disk got me thinking about all of it. Everything that changed. Everything that didn't. And whether we've actually been moving in the right direction this whole time.

1999 Was a Different Planet

Let me set the scene for anyone who wasn't there.

In 1999, most people were still on dial-up. 56k if you were lucky. You designed websites for 800x600 screens. Maybe 1024x768 if you were feeling ambitious. You tested in Netscape Navigator and Internet Explorer 4 and hoped for the best.

There was no CSS layout. Not really. If you wanted to control where things went on a page, you used tables. Not data tables. Layout tables. You'd take your design, slice it up in Photoshop or Fireworks, export the pieces as images, and reassemble them inside a grid of table cells. That was the job.

Image maps were a big deal. You could take one graphic and define clickable regions on it using coordinates. It was like building a puzzle that people could interact with. You'd map out rectangles and polygons by hand. If someone resized their browser, the whole thing broke. But it felt cutting edge.

Dreamweaver was how a lot of us built things. WYSIWYG editing. You could see what you were making while you were making it. Drag and drop. Visual layout. It generated the code for you. And that code was absolutely terrible. But it worked. And more importantly, it let people start building without needing to understand every tag and attribute first.

The Tools That Shaped Us

But HTML and Dreamweaver were only part of the picture. If you really want to understand 1999, you have to talk about Flash and Director.

Macromedia Director was a powerhouse. Before the web as we know it existed, Director was how people built interactive multimedia. CD-ROMs. Kiosks. Presentations. It had its own scripting language called Lingo, and it could export to Shockwave for the web. Director was doing interactive content before most people even had a browser installed. It was heavy, it was complex, and it was incredible for its time.

Then there was Flash. And Flash changed everything.

HTML in 1999 couldn't animate. It couldn't do smooth transitions. It couldn't play audio or video without a prayer and a plugin. Flash could do all of that. Splash pages with animated intros. Interactive navigation. Games. Entire websites built as a single .swf file. It was the closest thing we had to a rich application experience on the web.

Flash had its own language too. ActionScript. And this is where things get interesting. ActionScript was one of the first times a lot of web designers encountered real programming. Variables. Functions. Conditionals. Event handlers. It was based on ECMAScript, which means it was a cousin of JavaScript. A lot of people who eventually became serious developers cut their teeth on ActionScript inside Flash. It was a gateway into thinking programmatically.

JavaScript existed in 1999, but it was a different animal. You used it to validate forms. Maybe swap an image on hover. Write a little status bar message that scrolled across the bottom of the browser. Nobody was building applications with it. Nobody was even thinking about that. It was a scripting language. A utility. Something you sprinkled on top of HTML when you needed a little interactivity.

The idea that JavaScript would eventually replace Flash, power entire application frameworks, and become the most widely used programming language in the world? Nobody saw that coming. Not even close.

And then there was PHP.

PHP in 1999 was barely PHP. It was a template engine. That's literally what it stood for at first. Personal Home Page. You had an HTML file and you could drop in little blocks of dynamic content. Pull a date. Show a visitor counter. Maybe connect to a MySQL database and display some records. It wasn't a programming language the way we think about programming languages today. It was glue. It was a way to make static pages slightly less static.

But here's what made PHP matter. You could learn it in a weekend. You could write it right inside your HTML. You didn't need a compiler. You didn't need a framework. You uploaded a .php file to a shared hosting account and it just worked. The barrier to entry was almost nothing.

Sound familiar? That's the same thing that made Dreamweaver matter. And Flash. And Director. The tools that shaped that era all had one thing in common. They let people start building without requiring a computer science degree first.

That's the part I think we've lost sight of.

The Barrier to Entry Used to Be Low

Back then, you could go from zero to a published website in an afternoon. You didn't need to install Node. You didn't need a package manager. There was no build step. No webpack. No transpiling. You opened a program, you made something, you uploaded it to a server with FTP, and it was live.

Was the code good? No. It was terrible. Table layouts are a hack. Inline styles are a maintenance nightmare. Font tags should have been a crime. But people were making things. Regular people. People who didn't call themselves developers. People who just had an idea and wanted to put it on the internet.

The web was supposed to be for everyone. That was the whole point. Anyone could view source, see how something was made, and learn from it. You could right-click, look at the HTML, and understand the building blocks of what you were seeing.

Try doing that on a modern website. View source on most pages today and you'll see minified JavaScript that no human can read. The building blocks are buried under layers of abstraction. We didn't just raise the barrier to entry. We built a wall around it.

What Actually Changed (And What Didn't)

Here's the thing. The web itself hasn't changed that much. At its core, it's still the same technology. A browser requests a document. The server sends back HTML. The browser renders it. That's it. That's the web.

CSS came along and gave us real layout tools. That was a genuine improvement. We stopped using tables for structure and started using them for actual tabular data. Floats were painful. Flexbox was a revelation. Grid was even better. These were real steps forward.

JavaScript grew up. And I mean really grew up. That little scripting language we used to swap images on hover? It ate everything. It absorbed what Flash and ActionScript did. Animations. Rich interactivity. Audio. Video. Full application logic. All the things we needed plugins for in 1999, JavaScript eventually handled natively. When Steve Jobs killed Flash on the iPhone in 2010, it wasn't because Flash was bad at what it did. It was because the open web had finally caught up.

Director disappeared even earlier. Shockwave faded out. The plugin era ended. And honestly, that was the right call. The open web should be built on open standards. But we lost something in that transition too. Flash and Director had visual timelines. Drag-and-drop animation. You could see what you were building. The tools that replaced them are more powerful, but they're also more abstract. The creative accessibility those tools offered never fully came back.

PHP grew from a template engine into one of the most widely deployed server-side languages in history. WordPress runs on it. Which means a massive chunk of the internet runs on it. It's easy to look down on PHP today. Developers love to joke about it. But PHP powered the dynamic web before most of today's languages even existed. And it did it by staying approachable. You didn't need to understand object-oriented programming or design patterns to get started. You just wrote some code inside your HTML and it worked.

Responsive design changed everything too. The idea that one website could adapt to any screen size solved a real problem. We went from building separate mobile sites to building fluid layouts that worked everywhere. That mattered.

But somewhere in the mid-2010s, something shifted. The tools started serving the tools instead of serving the people using them. We began optimizing for developer experience at the expense of simplicity. And the complexity just kept compounding.

The jQuery Era and the CSS Framework Treadmill

Before we talk about complexity, let me talk about jQuery. Because jQuery might be the most important JavaScript library ever written. And most people under thirty have no idea why.

In the mid-2000s, writing JavaScript for the web was a nightmare. Every browser handled things differently. Code that worked in Firefox broke in Internet Explorer. Code that worked in IE6 broke in IE7. You spent more time writing browser workarounds than actual functionality. It was exhausting.

jQuery fixed that. One library. Write your code once. It works everywhere. Dollar sign, selector, do something. It was clean. It was readable. It made JavaScript accessible to designers and backend developers who had been avoiding it. jQuery didn't just simplify JavaScript. It democratized it. Suddenly everyone could add interactivity to their sites without losing a week to browser debugging.

And jQuery was everywhere. At its peak, it was on something like 70% of all websites. It was the default. For a lot of developers, jQuery was JavaScript. They learned the library before they learned the language.

CSS went through its own evolution. After we finally killed table layouts, we had floats. And floats were a pain. Clearing floats. Float drops. The holy grail layout that required three different hacks to work. We needed help.

Blueprint CSS showed up around 2007 and gave us something we'd never had before. A grid system. Predefined columns. Consistent typography defaults. It was one of the first CSS frameworks, and it felt like someone had finally brought order to the chaos. You included the stylesheet, added some class names, and your layout just worked. No more fighting with floats from scratch on every project.

Blueprint paved the way for what came next. 960 Grid System. YAML. Foundation. And then in 2011, Bootstrap came along and changed the game entirely.

Bootstrap gave you everything. Grid system. Typography. Buttons. Forms. Navigation. Modals. Dropdowns. Responsive breakpoints. All of it, out of the box. You could build a professional-looking website in a day without writing a single line of custom CSS. It was Dreamweaver logic applied to the modern era. Lower the barrier. Let people build.

The tradeoff? Every Bootstrap site looked like a Bootstrap site. The internet developed a sameness. The same buttons. The same navbar. The same card layouts. You could spot Bootstrap from a mile away. But it worked. And for a lot of businesses, looking polished and consistent mattered more than looking unique.

Now we've got Tailwind. And Tailwind is a completely different philosophy. Instead of pre-built components, you get utility classes. Tiny, single-purpose class names that you compose directly in your HTML. It's polarizing. Some developers love it because it's fast and flexible. Others look at a div with twenty class names on it and feel like they're reading a different language.

Here's the pattern I want you to see. Blueprint. Bootstrap. Tailwind. Three different eras. Three different approaches. All solving the same fundamental problem: how do you make CSS manageable at scale?

The answer keeps changing. The problem doesn't.

The CMS Graveyard

You want to see the churn in this industry? Look at content management systems. The CMS landscape is a graveyard of tools that were going to change everything.

I've watched so many come and go.

Mambo was one of the early open-source CMS platforms that people actually used. It was popular. It had momentum. Then the community fractured and Joomla forked off from it in 2005. Mambo faded. Joomla carried on. That's how fast things moved.

Joomla had its moment. For a while it was a real contender. It sat right between WordPress and Drupal in terms of complexity. Not as simple as WordPress, not as developer-heavy as Drupal. But it never found a clear identity, and over time its community thinned out. It's still around, technically. But the energy is gone.

Drupal was the enterprise choice. The serious CMS. If you needed complex content types, custom workflows, granular permissions, Drupal could do it. I built a lot of projects on Drupal over the years. But it demanded a lot from you. The learning curve was steep. Updates could be brutal. Drupal 7 to Drupal 8 was essentially a full rewrite that left a lot of agencies scrambling. It pushed people away who didn't have the resources to keep up.

WordPress won. That's the simple version of the story. It started as a blogging platform and just kept expanding. Themes. Plugins. Page builders. Gutenberg. WooCommerce. It went from "I want to write blog posts" to "I want to run my entire business" and it pulled it off through sheer ecosystem size. Is WordPress the best CMS from a technical standpoint? No. But it's the one that made content management accessible to regular people. There's that word again. Accessible.

Along the way there were others. Expression Engine had its loyalists. Textpattern had its niche. Concrete5 tried something different with in-page editing. Squarespace and Wix showed up and said forget the CMS entirely, we'll just host everything for you. Craft CMS earned respect from developers who wanted something cleaner than WordPress but more approachable than Drupal.

And now we're in the headless era. Contentful. Sanity. Strapi. The CMS doesn't even render your website anymore. It just holds your content and serves it through an API. Your frontend could be React, Next.js, Astro, whatever you want. The CMS became a database with a nice editing interface.

Every generation of CMS solved real problems. And every generation eventually got replaced by something that solved those problems differently. The content never changed. People still need to publish words and images on the internet. The machinery underneath just keeps getting rebuilt.

That's the thing about this industry. We keep rebuilding the machinery.

The Complexity Trap

Let me be clear about something. I'm not against new tools. I'm not against frameworks. Some of them solve real problems. But the industry has a habit of reaching for complexity when simplicity would work just fine.

I've watched this cycle repeat for twenty-six years.

A new framework shows up. It solves a specific problem really well. People start using it for everything, even problems it wasn't designed for. The ecosystem around it explodes. Now you need twelve dependencies just to get a project started. Then a newer framework comes along, and the whole thing starts over.

Meanwhile, the fundamentals haven't changed. HTML still works. CSS still works. Vanilla JavaScript is more powerful than it's ever been. You can build impressive, fast, functional websites without a single framework. But try telling that to someone who learned to code in the era of create-react-app. They'll look at you like you suggested they write assembly.

We've created a culture where you feel behind if you're not using the latest thing. Where job postings list fifteen technologies for what amounts to a CRUD app. Where junior developers feel overwhelmed before they even start because the landscape looks impossibly vast.

It doesn't have to be this way.

AI Didn't Simplify Things. It Added a New Layer.

Now we've got AI in the mix. And I'll be honest. It's a powerful tool. It's changing how we work. I use it. My team uses it. We'd be foolish not to.

But it didn't simplify web development. It added another layer on top of everything else.

AI can generate code faster than any human. That's a fact. It can scaffold an entire application in minutes. But someone still has to understand what it built. Someone has to debug it when it breaks. Someone has to know whether the code it generated is good, secure, and maintainable, or if it's just code that happens to run.

Writing code was never the hard part. I know that's a spicy take, but I've believed it for twenty-five years. The hard part is comprehension. It's building a mental model of how a system works. It's understanding what happens when you change one thing and something else breaks three layers down. It's knowing the right approach before you write a single line.

AI doesn't give you that. Not yet. Maybe not ever. It gives you output. Understanding is still a human job.

And here's the irony. AI has actually made it more important to understand the fundamentals, not less. If you can't read and evaluate the code that AI generates, you're not using a tool. You're trusting a black box. That's a different thing entirely.

What the Trades Can Teach Us

I work with contractors every day. HVAC techs. Plumbers. Electricians. Roofers. These are people who build and fix real things with real consequences.

You know what they don't do? They don't chase the latest trend for the sake of it. They learn their trade. They master their tools. When a better tool comes along, they evaluate it based on whether it actually helps them do the job better. Not whether it's new. Not whether it's trendy. Whether it works.

A good HVAC technician doesn't need the fanciest equipment on the market. They need to understand refrigerant cycles, airflow, electrical systems, and how buildings work. The fundamentals. Give a great tech basic tools and they'll diagnose a problem faster than a mediocre tech with every gadget available.

Web development could learn something from that.

Know your fundamentals. Understand how the web works at a basic level. Then choose your tools based on what the project actually needs, not what the industry is hyping this quarter.

What I'd Tell the Kid on That Zip Disk

If I could somehow reach back through time to that kid sitting in a computer lab at Champlain College, building his first website with image maps and table layouts, here's what I'd tell him.

You're on the right track. The things you're learning right now, how HTML structures a page, how elements relate to each other, how a browser turns code into something visual, those things are going to matter for your entire career. The tools will change a hundred times. The fundamentals won't.

Don't let anyone make you feel like what you're building isn't real because you used Dreamweaver instead of writing code from scratch. You're learning how to think about building for the web. That's the skill. The syntax is just the language you use to express it.

Stay curious. Stay building. Don't over-complicate things.

Keep it simple. Make it look beautiful. Have it work.

The Disk Is Making the Move

I still can't open that Zip disk. I still don't have a drive. But it's packed in a box with my name on it. It's coming with us to the new place.

Not because I think what's on it is good. I'm sure it's terrible. Tables nested inside tables. Image maps with hardcoded coordinates. Dreamweaver-generated markup that would make modern linters crash.

But it's the start. It's proof that twenty-six years ago, a kid sat down at a computer and decided to build something for the web. And he never stopped.

The tools changed. The industry changed. The complexity grew in ways none of us could have predicted.

The curiosity didn't change. The fundamentals didn't either.

If anyone has a working Zip drive collecting dust somewhere in Vermont, let me know. This disk and I have some catching up to do.

WordPress Just Shipped Three Updates in 24 Hours. This Is What Bad Code Looks Like at Scale.

WordPress 6.9.4 dropped this morning. If that version number doesn’t mean anything to you, don’t worry. You also missed 6.9.2 and 6.9.3. They all came out in the same 24-hour window.

A security patch broke things. So they patched the patch. Then patched it again. Three updates in a day for a platform that powers over 40% of the web.

I’ve been building websites for a long time. I’ve watched WordPress go from a simple blogging tool to the default answer for everything. And I think that’s one of the worst things that’s happened to the internet.

The Problem Isn’t the Attack. It’s the Architecture.

Here’s what kicked this off. Attackers were compromising WordPress sites and injecting fake CAPTCHA prompts. Visitors thought they were verifying they were human. Instead, they were tricked into running commands that installed malware on their machines.

That’s bad. But it’s not surprising.

WordPress is a patchwork. Always has been. The core tries to do everything. Then you bolt on plugins and themes written by thousands of different developers with thousands of different skill levels. Some of that code hasn’t been touched in years. Every one of those pieces is a door. And most of them don’t have locks.

When WordPress pushes a core security fix and it immediately breaks plugins across the ecosystem, that’s not bad luck. That’s a design problem. That’s what happens when there’s no real standard for how code should behave inside the system.

Good Code Doesn’t Need Three Patches in a Day

I have a simple philosophy. Keep it simple, make it look beautiful, and have it work.

That last part is the one people skip. “Have it work” doesn’t mean “have it work today.” It means have it work tomorrow. Next month. When someone else has to maintain it. When a dependency changes. When you push an update and a thousand other things are counting on your code to not break theirs.

Good code is boring. It’s predictable. It does what it says it’s going to do and nothing else. You can read it six months later and understand what’s happening without a translator.

Good code doesn’t need an emergency patch 12 hours after the last emergency patch.

WordPress Doesn’t Reward Good Code

Here’s the real issue. WordPress became popular because it was easy. Install it in five minutes. Pick a theme. Add some plugins. You’ve got a website.

But easy up front and easy to maintain are two completely different things.

The WordPress ecosystem rewards speed to market. Build a plugin fast, get it listed, get downloads. There’s no real quality gate. No one’s reviewing that code before it goes live on a million websites. And when something breaks, the site owner is the one scrambling at 7 AM to figure out which update killed their contact form.

That’s not a technology problem. That’s a values problem. The platform chose scale over standards a long time ago.

What Good Code Actually Looks Like

It’s simple. Not clever. There’s a difference. Clever code impresses other developers for five minutes and confuses everyone else forever. Simple code just works. You read it and you know exactly what it does.

It’s modular. When one thing changes, everything else doesn’t fall over. You can update a component without holding your breath and hoping the whole system survives.

It’s tested. Not just “I clicked around and it seemed fine.” Actually tested. Edge cases. Bad inputs. The weird stuff real users do that developers never think of.

It’s maintained. Someone owns it. Someone updates it. Someone cares whether it still works next year.

WordPress core tries to do some of this. But the ecosystem around it doesn’t. And when your platform depends on an ecosystem of code you can’t control, you’ve already lost.

Stop Babysitting Your CMS

If you’re a business owner and your website is a constant maintenance project, something is fundamentally wrong. Your website should be a tool that works for your business. Not a part-time job.

You shouldn’t need to wonder whether today’s update is going to take down your site. You shouldn’t need to manage 30 plugins just to have basic functionality. You shouldn’t wake up to three update notifications before your first cup of coffee.

There are better ways to build websites today. Cleaner. Simpler. More secure by design instead of secure by endless patching.

The web is still built on HTML, CSS, and JavaScript. That hasn’t changed since I started. The fundamentals still matter more than the framework. And a well-built site on a clean stack will always outperform a bloated WordPress install held together by plugins and prayers.

The Bottom Line

WordPress shipping three updates in 24 hours isn’t just a bad day. It’s a symptom. It’s what happens when an entire ecosystem is built on the idea that anyone can build anything without worrying too much about how.

That’s not freedom. That’s technical debt on a global scale.

If you’re running a business on WordPress, take a hard look at what you’re actually getting. And if the answer is “a site that breaks every time there’s an update,” maybe it’s time to build something better.

Keep it simple. Make it look beautiful. Have it work.

That’s not a tagline. That’s the standard.

Work Should Be Fun. I'm Not Kidding.

I never wanted to be a leader. That was never the plan.

I wanted to sit in the corner and build stuff. Write code. Solve problems. Put my headphones on and disappear into the work. That's what made me happy. That's what got me into this 25 years ago.

But here's what I learned. To build anything worth building, you can't do it alone. And that means being vulnerable enough to admit you don't have all the answers. It means looking at someone on your team who is better than you at design, or project management, or talking to clients, and saying "I need your help."

That's not weakness. That's how good teams actually work.

And once I figured that out, everything changed. Because suddenly the team wasn't just a group of people working on the same project. It was a group of people filling in each other's gaps. Making each other better. And that's when the work started being fun in a way I didn't expect.

People Make the Team

Every person on a team brings something different. That's the whole point.

Someone brings calm when the deadline is breathing down your neck. Someone else brings energy when the project feels like it's dragging. There's the person who catches the details everyone else missed. The one who asks the question nobody wanted to ask but everybody needed to hear. The one who makes you laugh in the middle of a long week and reminds you that this is supposed to be enjoyable.

That mix is everything. You can't manufacture it. You can't put it on a job description. But when you have it, you feel it. Our team at Red Barn is proof of that. The work moves faster. The communication is easier. People aren't protecting their turf. They're building something together.

And when that's happening, the stress doesn't disappear. But it changes. It stops being the kind of stress that wears you down and turns into the kind that pushes you forward. Because you know the team has your back. And they know you have theirs.

That's when work and fun become the same thing.

Trust Changes Everything

Here's the thing about deadlines and pressure. They don't go away. Ever. If you're building something that matters, there will always be a moment where the timeline gets tight and the stakes go up.

What makes the difference is the team around you when it happens.

When the team trusts each other, nobody wastes time looking over shoulders. Nobody burns energy second-guessing the plan. When someone says "I got this," the rest of the team believes it and moves forward. That's how good work gets done.

I'm not talking about ping pong tables and free snacks. I'm talking about the kind of fun that comes from being part of a team that actually functions. Where people show up, do great work, and have each other's backs. That's fun. Real fun.

Growth Is Great Until It Isn't

Red Barn has been growing. And I'm proud of that. We've taken on bigger projects, pushed into new areas, and built out the team to match.

But growth has a way of showing you things you didn't want to see.

When the team is small, everybody pulls their weight because there's nowhere to hide. You can feel the energy in the room. Everyone knows the mission and everyone is rowing in the same direction.

As you grow, that changes. Not always in obvious ways. Sometimes it's subtle. A meeting that didn't need to happen. A task that took three times longer than it should have. A conversation that went in circles because the team wasn't aligned. A process that suddenly needs a process.

And sometimes you realize the team isn't operating the way it used to. The rhythm is off. Communication breaks down. Things slip through cracks that didn't used to exist. The collective momentum that made everything click starts to feel harder to maintain.

That's not about pointing fingers. That's just the reality of growth. Teams change shape, and not every version of the team moves at the same speed.

Efficiency Is a Team Sport

When I talk about efficiency taking a hit, I don't mean some number on a dashboard. I mean the team feels it.

Work gets redone because communication wasn't clear. Projects stall because alignment wasn't there from the start. Decisions take longer than they should because the team isn't in sync. Energy that should be going into building great work gets burned on friction instead.

That stuff adds up. And it doesn't just slow things down. It kills the energy. It chips away at that trust I was just talking about. It makes the fun disappear.

When a team falls out of rhythm, everything gets harder. Not because the work changed. Because the way the team operates changed.

Protect the Culture

The longer I do this, the more I believe that culture isn't something you build once and forget about. It's something you protect. Every day.

That means being honest when something isn't working. It means having hard conversations before small problems become big ones. It means building a team that cares about the work and about each other, not just the output.

And it means remembering why we're here in the first place.

I got into this because I love building things. I still do. I'd still be happy in the corner writing code if that's all it took. But building something real takes more than one person. It takes a team that trusts each other enough to be honest about what they're great at and where they need help.

Work should be fun. Not every minute of every day. But overall, if the team isn't enjoying what they do and who they do it with, something is wrong. And it's worth fixing.

We're building something at Red Barn. And I want the team to feel that. To know that the trust is real, the work matters, and yeah, it's okay to have a good time while you're doing it.

Because the best teams I've ever been on? They were the ones where the work and the fun were the same thing.

Someone Paid Influencers to Tell You SEO Is Dead. Here’s the Proof.

5 months ago, someone posted a leaked creator brief on Reddit that confirmed what a lot of us in the SEO industry already suspected.

https://www.reddit.com/r/SEO/comments/1nm6daz/fyi_geos_ugly_campaign_of_intentional/

A company called Search Party, a GEO (Generative Engine Optimization) startup that just raised $3.5 million in venture capital, sent outreach to top SEO creators offering paid sponsorships and long-term equity. In exchange, those creators would push a very specific message to their audiences.

The brief said, word for word:

“GEO is the future. Traditional keyword-first SEO is becoming outdated.”

That’s not a hot take. That’s a script. With a check attached to it.

This is the post I’ve been wanting to write for a while. Let’s talk about why they did it, why it matters to you, and why the data says they’re completely wrong.

Why They Did It: You Can’t Sell a Solution Without a Problem

Search Party came out of stealth in October 2024 with $3.5 million in funding and a product to sell. The problem? Businesses were already spending money on SEO. If SEO works, nobody needs what they’re selling.

So they created the problem.

This is the oldest playbook in tech marketing. You can’t sell a painkiller without pain. You can’t sell a life jacket to someone standing on dry land. So you have to convince people the ground is underwater.

Here’s how the operation worked, based on the leaked brief:

Phase 1: Paid creator partnerships. Starting October 7th, they launched sponsored content deals with SEO influencers. These creators would produce content “introducing Search Party to the market and helping define what generative engine optimization means.” In other words, paid advocates framing the narrative in Search Party’s favor.

Phase 2: Creator Advisory Board with equity. For select partners, they offered long-term equity in exchange for “consistent feedback, product shaping, and ongoing advocacy” over a two-year engagement. Not just a one-off sponsored post. A two-year commitment to push the brand.

The talking points they wanted amplified:

  • “AI agents replace manual GEO complexity”
  • “GEO is the future. Traditional keyword-first SEO is becoming outdated.”
  • “[Our platform] helps brands influence how they show up in LLMs”
  • “This isn’t another SEO tool, it’s a new model”

These aren’t organic opinions from independent creators doing their own research. These are coordinated messages, paid for by a VC-backed company, distributed through trusted voices to their audiences, most of whom have no idea the content is sponsored.

This is not illegal. The FTC requires disclosure of paid partnerships. But disclosure gets buried. A small “#ad” tag at the bottom of a post doesn’t undo the psychological weight of a trusted voice telling you your SEO strategy is obsolete.

And Search Party isn’t alone. They’re the one who got caught. The broader GEO software category, tools that claim to help you “optimize for AI,” has a collective financial interest in making you believe SEO is dying. The GEO tools market is growing fast, and every dollar that moves from SEO budgets to GEO subscriptions is a win for them.

Meanwhile, 81% of marketing leaders reported pulling funds away from SEO to spend more on social and influencer marketing, exactly the outcome these campaigns are designed to create.

Why It Matters: Real Businesses Are Making Bad Decisions Based on Paid Narratives

I work with HVAC companies, plumbers, roofers, and electricians. These are small business owners running crews, managing jobs, and trying to figure out where their next customer is coming from. They don’t have time to sift through whether a LinkedIn post is sponsored or genuine. They trust the people they follow.

When a trusted voice tells them SEO is dead, some of them believe it. And then they make decisions based on that belief.

They pull back on the content they’ve been building. They stop investing in their Google Business Profile. They start chasing the next thing: some new tool, some new strategy, some new subscription, because they’ve been convinced the thing that was working for them is no longer worth the investment.

That’s a real business harm.

According to Search Engine Journal, organic search remains responsible for over half of all website traffic. And for local service businesses specifically, the stakes are even higher. When someone’s furnace goes out at midnight, they’re not asking ChatGPT. They’re Googling “emergency HVAC near me.” That search goes to whoever shows up in the local pack. That’s SEO. That’s a real customer with a real problem and real money.

The businesses that abandon SEO based on a funded narrative aren’t just wasting their subscription dollars. They’re ceding ground to competitors who kept their heads down and kept building.

As one independent analysis put it, the real risk for small businesses isn’t losing search visibility to AI. It’s overreacting to scare tactics and wasting budget on “GEO packages” that don’t deliver.

Why They’re Wrong: The Data Doesn’t Support the Narrative

Let’s talk about what’s actually happening in search, not what a VC-backed startup needs you to believe.

Google is not dying.

Google still controls 89% of all U.S. web traffic. That’s not a dying platform. That’s a monopoly. And Google search grew by 21% in 2024, the same year everyone was telling you AI was going to kill it.

ChatGPT is not replacing Google search.

Semrush data shows that only 30% of ChatGPT prompts are similar to how people use search. The rest is chatting, writing, brainstorming. People using ChatGPT to plan a recipe or debug code are not the same people who were going to Google “best HVAC company in Burlington.” These are different behaviors, different use cases, different audiences.

AI Overviews are not a traffic apocalypse.

Yes, AI Overviews show up in about 13% of Google searches. Not 60%, not 80%. Just 13%. And blog posts and news articles make up the majority of sources cited in those AI Overviews. Meaning the content you’ve been creating for SEO is now also feeding AI responses. That’s not a threat. That’s an expanded distribution channel for the same work.

The SEO industry itself is growing.

The global SEO services market is projected to grow at a compound annual growth rate of 16.2%. Companies don’t pour billions into a dying channel. 91% of marketers in 2024 said SEO had a positive impact on their website performance and marketing goals.

Google still dominates AI traffic too.

Google drives 345 times more traffic to websites than ChatGPT, Gemini, and Perplexity combined. Read that again. 345 times more. GEO optimizes for a channel that sends a fraction of a percent of the traffic that Google sends.

Now, to be fair: search is evolving. It always has. AI is changing user behavior at the margins, especially for informational queries. Young people are using TikTok as a discovery tool. Zero-click searches are a real thing that reduces traffic to some websites. These are legitimate trends worth paying attention to.

But none of that is “SEO is dead.” What it is, is SEO evolving, the same way it has evolved through every major algorithm update since I started building websites in 1999. Panda. Penguin. Hummingbird. Mobile-first. Core Web Vitals. The people who declared SEO dead at each of those milestones were wrong every time.

As one sharp observer put it: “Imagine claiming that photography died when film cameras became obsolete. Digital photography didn’t kill the art form. It transformed it.”

What Good GEO Advice Actually Looks Like

Here’s where I’ll give credit where it’s due: there are legitimate things happening in AI search that are worth understanding.

Benjamin Houy, who actually built a GEO platform and then shut it down despite having paying customers, said something worth remembering: the best way to show up in AI-generated answers is to be an authoritative source on the topic you care about. Create real content. Earn real mentions. Build a real reputation.

Sound familiar? That’s SEO.

The fundamentals haven’t changed. Build something worth finding. Help real people with real questions. Show up consistently. The channel that surfaces your content has changed shape over the years. The underlying principle never has.

You don’t need a $3.5M funded subscription to do that. You need to actually know something, actually say it clearly, and actually be useful.

The Bottom Line

Search Party got caught because someone posted the brief. But there are dozens of companies running similar playbooks right now that haven’t been caught. Every time you read a LinkedIn post, a newsletter, or a YouTube video from an SEO creator telling you “SEO is dead, here’s what to do instead,” ask yourself who’s paying them and what they’re selling.

That’s not cynicism. That’s how you protect your business from making expensive decisions based on someone else’s marketing budget.

I’ve been building digital marketing for home service contractors for 25 years. I’ve watched the “SEO is dead” cycle repeat on a near-annual basis. Every time, the businesses that kept their heads down and kept doing the fundamentals came out ahead.

SEO is not dead. Shortcuts are dead. Gullibility is expensive. And some people are betting real money that you won’t notice the difference.

Now you know.

Stephen Quick is the CTO of Red Barn Media Group, where he’s spent 25+ years building digital marketing solutions for HVAC and home service contractors. He started his career during the first dot-com era and still believes the best technology is simple, beautiful, and works.

Have questions about your SEO strategy? Contact Red Barn Media Group.

AI Didn’t Change What We Do. It Gave Us More Time to Do It

I’ve been building websites since 1999. In that time I’ve watched a lot of technologies get called game-changers. Most of them were just new ways to do the same things.

AI is actually different. But not for the reason most people think.

The conversation in our industry keeps framing AI as a threat. Who’s going to lose work. Which roles are going away. Who survives. I understand why the conversation goes there but I think it’s asking the wrong question.

The right question is: what can you do now that you couldn’t do before?

What We Used to Spend Time On

Building a website for a contractor has always involved a lot of mechanical work. Structuring pages. Writing boilerplate. Formatting content. Generating variations. The work that fills hours but doesn’t require the kind of thinking that actually makes a client’s business grow.

That work had to get done. We did it. But it was never the part of the job that moved the needle.

The part that moved the needle was always the strategic layer. How do we structure this service page to convert a homeowner who’s comparing three contractors? What does the UX look like on mobile when someone’s standing in front of a broken furnace at 8pm trying to find a phone number? Where are we losing people in the funnel and what do we test first?

That work requires judgment. Experience. An understanding of how homeowners actually behave when they’re making a buying decision about something they don’t want to spend money on.

AI can’t do that. But AI can handle a lot of what used to eat the time we needed to get there.

What This Actually Looks Like

We code everything at Red Barn. No CMS. No page builders. No templates. That’s been true for twenty-five years and it’s not changing. But the way we build is changing.

AI handles more of the mechanical output now. That’s not a threat to how we work – it fits how we work, because we understand the code well enough to evaluate what gets generated and build on top of it. We’re not handing the wheel over. We’re moving faster through the parts of the job that were never the point.

What that frees up is real.

More time in the UX layer. More time thinking about page structure, user flow, where friction lives and how to remove it. More time actually running tests instead of talking about running tests. More time on the strategic decisions that compound over months – the ones that determine whether a client’s site generates leads or just exists on the internet.

That’s where we want to be spending our time. AI is helping us get there.

The Developers Who Are Going to Struggle

There are developers in this industry whose entire value proposition was production speed. They could spin up a WordPress site in two weeks. They knew the plugins. They could assemble something that looked like a website fast.

AI is faster. That’s just true. If your competitive advantage was output volume, the math has changed.

But that was never the job we were doing. The job was always outcomes – more calls, more leads, more booked jobs for the contractor trying to grow their business. Production was just the cost of entry.

The developers who understood that are in a better position now than they’ve ever been. The ones who were just producing output are going to have to figure out what they actually know how to do.

What Clients Are Actually Paying For

This is worth saying directly.

When a contractor hires Red Barn, they’re not paying for code. They’re paying for twenty-five years of understanding how homeowners find and choose a contractor. They’re paying for the UX decisions that turn a visitor into a phone call. They’re paying for the A/B tests that tell us what’s actually working instead of what we think should work. They’re paying for the judgment that knows when something is wrong with a site before it shows up in the numbers.

AI doesn’t have any of that. It can generate a page. It can’t tell you whether the page is built to win.

That’s the work. That’s what we’re here to do. And we have more capacity to do it now than we did two years ago.

The Bottom Line

AI didn’t disrupt what we built Red Barn to be. It cleared the path to it.

The mechanical parts of web development are getting faster and cheaper. That’s good. It means the value shifts to exactly where it should have been all along – strategy, user experience, testing, and the deep understanding of what makes a home service business grow.

We’ve spent twenty-five years building that understanding.

We’re just getting started.