60 Job Postings That Make Marketers' Next Dividing Line Crystal Clear

A few days ago, I did something a little boring: I read 60 marketing job descriptions (JDs) that were still posted, from top to bottom.

All of them were listed on companies' own career pages and confirmed to be still open. There was only one criterion for inclusion: the JD mentioned AI.

By the time I finished, my stomach dropped.

Let me give you two numbers first.

Hiring Lab, the research arm of the recruiting platform Indeed, has tracked this: in 2025, the share of marketing job postings that mention AI rose from 8.4% to 14.9%. One year. Almost doubled.

PwC's 2026 edition of the AI Jobs Barometer is even more blunt. It analyzed over a billion job postings, and its conclusion: people with AI skills command a 62% wage premium.

62%. Think about that. Same job, same title — but because you can put AI to work, you take home 60 percent more.

But neither of those two numbers is why my stomach dropped.

What really stopped me cold was this: of the 60 JDs, 45 stated in black and white that the hire must be able to design and deliver AI agents and automation workflows.

45 out of 60. And only 2 of them labeled this a "bonus."

The remaining 43 listed it as a hard requirement.

Employers are no longer satisfied that you know how to write prompts. What they want are people who can build systems.

One company put it unusually bluntly in its JD, in essence: the way this job works is AI itself. We're looking for people with a builder's mindset — people who understand workflows, who understand agents, not people who can only write prompts.

When I read that line, my first reaction was: uh-oh. A lot of marketers' resumes already don't match that requirement.

What's Worse: The Job Titles Haven't Changed a Word

Here's the interesting part — the titles of those 60 JDs.

Only 1 put AI-native in the title.

In 33 titles, the letters AI never appear. So where are the requirements hiding? Inside the job description of something called a marketing operations specialist.

See, that's the most camouflaged spot of all.

The title doesn't move. The requirements do. By the time of your next compensation review, the requirements under the table have already been swapped out — and your resume is still written to the old ones.

So the question becomes: what do these requirements actually mean? And which capability should you build first?

The Tooling Layer Is More Specific Than You Think

Employers used to ask: have you used AI?

They don't ask that anymore. Now they call out products by name.

Of the 60 JDs, 36 named at least one specific product.

Let me break down the name list for you.

First: the models you'd use every day.

Claude appears in 26 of them. OpenAI or ChatGPT, 19.

Wow. When I first saw those numbers, I froze for a second. A lot of people assume the market revolves around ChatGPT — yet on the front lines of hiring, Claude gets named more often.

Second: an orchestration platform — and they want you fluent in it.

The platforms named in the JDs were mainly three: n8n, Zapier, and Make. How long does it take to get fluent in one? Someone did the math: about 15 hours for n8n, 12 for Zapier, 8 for Make.

Sounds like a lot. Don't panic. All three run on the exact same underlying logic: a trigger, a series of steps, a few conditional checks, and an output at the end. Get fluent in one of them and switching to another is an afternoon's work.

Which to pick? Pick the one your company is already paying for.

Third: a way to get your own data within reach of the model.

Model Context Protocol (MCP) exists precisely for this. It lets an agent reach directly into your tools and data, instead of guessing from whatever it memorized during training. Of the 60 JDs, 8 already name it.

By the way, this protocol only came out in 2024. Two years — from nonexistent to written into JDs.

Fourth: the part marketing essays usually skip — coding assistants, the repositories that hold the code, and the places where things go live. One of each:

• For writing: Claude Code, Cursor, or Replit.
• For storing: GitHub.
• For shipping: pick one of Vercel, Railway, Render, Supabase, or Firebase.

One JD put it in so many words: AI coding tools — it listed Claude Code, Cursor, and Replit in parentheses — to build custom solutions; plus, you need to know how to use GitHub.

Keep that list handy. But let me warn you: this list is a consumable. In roughly two years, half of it will have churned.

Whether Claude is still on the list two years from now, nobody can say.

So what isn't a consumable?

The ladder.

What Do I Mean by the Ladder? Five Rungs, and You Must Climb Them in Order

Once I'd read all 60 JDs, I realized they were describing the same capability ladder. Five rungs:

1. Understand how it works
2. Write the process down
3. Automate the repetitive
4. Build an app on your own and ship it
5. Prove it's still alive next month

Why a ladder, and not a buffet, where you take whichever dish you fancy?

Because every rung stands on the one before it.

The most common mistake — and I've seen plenty of it — is skipping rungs: the principles still fuzzy, the process never written down, but the "Build AI Agents" course already paid for.

Why doesn't that work?

Because an agent executes, strictly, whatever process you hand it. What happens if what you hand it is a process you never managed to write down clearly?

The output looks right. Clean formatting, on-brand style, a confident tone. But the errors are buried deep. Nobody notices, and it can be wrong for an entire quarter.

By the time you catch it, the damage is already on the books.

All right. Let's climb, one rung at a time.

Rung One: Understand How It Works

Not to show off jargon. So that it stops scaring you.

How does a model produce an answer?

It doesn't go rummaging through an inventory for a ready-made answer to hand you. It generates on the spot, one word at a time: with every word it writes, it uses everything in front of it to guess the most likely next word.

"Everything in front of it" has a name: the context window.

For a model, the context window is its entire world. Last week's events, last month's proposals — if you don't place them into its world yourself, it doesn't know them.

Then how does it reach your company's own materials?

Off the shelf, a model carries only what it learned in training. That's why it can say, with a perfectly straight face, that you sell a feature you've never sold.

To get it speaking your company's language, you have to feed it your documents first: turn each chunk of text into a string of numbers — an embedding. You can think of an embedding as a coordinate; passages with similar meaning sit close together. Those coordinates get stored in a vector database.

Someone asks a question. The question gets turned into a coordinate too, the passages nearest to it are pulled from the database, stuffed into the context window, and only then does the model start talking.

This whole mechanism is called retrieval.

You'll probably never build this yourself, but you must know it's happening — because the quality of your documents influences the quality of the output more than which model you pick.

Three more things, the earlier you know them the better:

• It doesn't remember. What you discuss this session is forgotten next session, unless you deliberately give it memory. So a bloated, rambling brief will drown the one requirement you actually care about.
• It will always give you an answer. Producing plausible-sounding prose is its entire operating mechanism, not a malfunction.
• Ask the same question twice, and the answers may differ. It picks among "possible continuations"; it isn't looking things up in a table.

Finally, three things that live outside the model — you have to keep them straight.

An agent is not a chat box. It's configured software: given fixed tools, run on a schedule, doing the same thing over and over, then writing the results to a designated place.

A skill is the instruction manual you write for an agent, so it does the work your way.

MCP, covered earlier, is the system that lets an agent reach your tools and data.

When do you pass this rung?

When you can explain all of this to your grandmother — without drawing a single diagram.

Rung Two: Write the Process Down

What does "write the process down" actually mean?

Take the work you currently do by feel, by experience, by muscle memory, and break it into a string of steps. Spell out each one: what the input is, where the judgment call sits, who takes over next.

This exercise has another name: the cheapest audit there is.

Write it out once and you'll see for yourself: the approval steps nobody can explain the reason for, the stages that survive only because "someone mentioned it once years ago," the handoffs that quietly swallow an entire day — all of it floats up onto the same sheet of paper.

If a process can't be written down, it can't be automated. Work you can't describe, you can't hand an agent.

But this rung has a harsher part.

Standards have to be written down too.

Brand guidelines, tone-of-voice guides, design systems — those were all written for human readers. Humans ask follow-up questions, read the room, and fill in the spirit of a 40-page PDF on their own.

Agents don't.

A 40-page PDF with mood boards doesn't fit inside a workflow. The same knowledge has to be rewritten as rules. Which categories go first? Let me count them out for you.

Voice. Don't write adjectives. Paste in passages you've actually published, one by one, and mark why each one is good. Examples teach a model a hundred times better than adjectives do. Then list the failure patterns you've actually seen, so the machine has something to veto. For instance: open with the reader's problem, not the product; never stack three adjectives in a row; say what it does before you say who it's for.

Product truth. One page per product, with an owner and a review date: features, limits, target customer, plus the head-to-head playbook against every competitor. Take TMetric, a time-tracking tool for service teams: it handles timesheets, billing rates, and project margins; the target customer is the operations lead at teams of 20 to 200 people; against competitors, they win on price, we win on approvals.

Claims list. Which statements you can make outright, which require a source link attached, which no one is allowed to make. Get sloppy here and the agent will confidently invent a competitor comparison out of thin air.

SEO and GEO (generative engine optimization) rules. What a page should look like and how it earns rankings and AI citations: section order, length ranges, which search intent pairs with which format, internal links, structured data — and which passages deserve to be quoted directly in AI answers. For a comparison page, state the answer clearly in the first 40 words so it can be quoted; table first, prose after; never build a second page for a keyword that already ranks.

Design system. Web pages and images alike. Components, states, design tokens, usage rules — kept somewhere alive (say, Storybook), not locked in a slide deck. Generated images get their own rules: how the logo sits, what style, what may absolutely never be generated.

Once these are written, your team — humans and machines — reads from the same manual.

Rung Three: Move the Repetitive Work Up, One Piece at a Time

The point of the ladder starts paying out at this rung.

Pick out the tasks that repeat every week: first, one polished prompt. Once you've worn it in, save it as a reusable skill. Later still, attach a trigger to that skill — and it becomes an agent you no longer have to think about.

Automate one, free up your time, pick the next.

By the way, quite a few JDs say the employer wants someone who can build systems for the whole team — shared libraries.

Notice: build shared libraries. Nobody asked you to surrender your prompts.

What you owe them isn't a few incantations. It's a machine that keeps running even when you're not around.

Rung Four: Build an App on Your Own and Ship It

This is the rung marketers resist most.

But here's the interesting part: the rung with the fiercest resistance is exactly the rung with the biggest payoff.

Find one small task your team currently does by hand. Don't go big. Go real. Build it yourself with a coding assistant, put it in a repository, deploy it, give it a URL other people can click.

Why walk the full chain? Because every segment teaches a different lesson.

While building, you learn scoping. Vague requirements produce vague products — and you'll learn that lesson with your own hands twenty minutes in, no need to wait for the quarterly retrospective.

When you put it in the repository, you learn versioning. The first time you break something is when you understand how precious the word "rollback" is.

And when you ship it, everything finally lands: people use it, people give feedback, and someone breaks your thing in ways you'd never have imagined.

Finish this once, and your brain starts running on different software.

Some understanding only comes from doing. Watch a thousand tutorials, and you've only heard about it.

Rung Five: Prove It's Still Alive Next Month

This is the rung most easily ignored.

Write down the business outcome the automation is supposed to produce, then check the numbers at 30, 60, and 90 days: achieved, on track, or already falling behind.

What this step teaches you is something the first four rungs can't teach you:

Your automation will degrade.

An agent that ran beautifully in March is not evidence it runs beautifully in September.

You know a garden needs regular tending. Why would systems be the exception?

Stop Waiting for a Course

If you've read this far, you've probably already seen it coming: not one of these five rungs can be climbed for you by signing up for a class.

Stop waiting for that "AI Marketing Bootcamp" to open enrollment.

Pick one process you run through every week. Write it down. Measure it honestly. Automate one piece of it. Put the results somewhere your teammates can reach too.

Next month, do it again.

One hour a day, invested in real tasks, is more than 300 hours of genuine accumulation in a year. All those courses that never get put into practice — not one minute of that time ever grows into capability.

Back to those 60 JDs from the beginning.

The job titles never changed. The requirements under the table did. The ones who see it start climbing the ladder; the ones who don't are still hoarding tools.

Here's wishing you're the one who climbs first.