The Next Scarce Skill: Curation

Curating The Output Flood

The internet used to feel like a library. Now it feels like a skip.

Not because the average person suddenly got worse at writing. Not because the web got “too big”, but because we’ve industrialised output. AI didn’t invent noise, it just made it cheap. And when noise becomes cheap, attention becomes expensive.

Over the years I’ve been speaking to curation professionals across a wide range of disciplines - editors, librarians, museum people, club organisers, DJs, moderators, researchers, archivists.

You get some properly odd stories. Daylight bone robbery. Pre-clubnight intentional check-ins. Curation isn’t always taste. Sometimes it’s security. Sometimes it’s provenance. Sometimes it’s making sure the wrong thing doesn’t get through the door.

Different domains, same problem: when output becomes abundant, noise becomes abundant. And when noise becomes abundant, curation stops being a nice-to-have and turns into infrastructure.

So here’s the shift I keep seeing in product teams, content teams, and design teams:

Production is no longer the signal of competence. Curation is.

Not “curation” as in “we made a playlist just for you”. Curation as in the ability to choose, shape, and stand behind what matters - repeatedly - under pressure. Even whilst that bliblical output flood keeps rising.

There’s a fable trying to happen here and I’m going to let it, briefly.

We’ve built an artificial hare - fast, tireless, delighted with itself. It can lap the track all day producing plausible things with that unnerving, gym-bro confidence and a winning smile. If you’ve seen the Duracell bunny adverts you know the drill.

The biological tortoise is the rest of us. Slower. Annoyingly mortal. Still having to do the boring part: judgement, context, responsibility.

The race isn’t really about speed any more. It’s about what survives review.

So the bottleneck moves. It’s no longer making things. It’s deciding what deserves to exist.

That decision is increasingly a curation problem.

And because decisions require buy-in, curation becomes an articulation problem too.

Choice Or Decision?

One of the most common failure modes I see with AI-assisted work is that it produces a lot of choices and very few decisions.

Choices are cheap. Decisions are expensive.

A choice is:

• “This one feels better.”
• “Let’s go with option B.”
• “The wizard is clearer.”

A decision is:

• “We’re choosing the wizard because it reduces the number of concepts a first-time user must hold in working memory from five to two.”
• “We’re accepting the trade-off that power users will need one extra step, because the support burden from misconfiguration is currently killing us.”
• “If we’re wrong, we’ll see it in task completion and error rate inside two weeks.”

AI massively increases the number of choices available. Ten, fifty, a hundred plausible answers. And plausible is often the problem.

If everything is plausible, the team starts drifting. You get that familiar fog:

• Lots of output
• Lots of “alignment”
• Surprisingly little clarity
• A decision you can’t quite explain later

This is the articulation gap - the space between what you know and what you said. The reasoning stays in your head, the room moves on, and a week later you’re writing it up thinking, “Wait - why did we do that again?”

AI makes this worse, not better. Because it gives you momentum without accountability.

The Flood Is The Feature

AI is brilliant at turning prompts into plausible stuff:

• A plausible explanation
• A plausible interface
• A plausible onboarding flow
• A plausible strategy doc

It gets you to “something” fast, which is genuinely useful.

But plausible output has a side effect: it makes everything look equally deserving of consideration. Generate ten options and they all sound fine. Generate a hundred and they still sound fine.

You don’t get a clear “best”. You get a room-temperature soup of competent-sounding maybes.

So the job shifts from generating to curating.

Curation Is Not Taste, It’s Accountability

People talk about curation like it’s vibes. Like it’s a monocle and a not so faint disdain for mainstream TV.

In practice, curation is much less romantic.

Curation is when you:

• Pick what to include
• Pick what to exclude
• Decide what order it should appear in
• Explain why
• Accept responsibility for the outcome

That “explain why” bit is where most teams wobble, because we confuse explanation with justification.

Explanation is:

• “Here are the criteria.”
• “Here’s what we prioritised.”
• “Here’s what we traded off.”

Justification is:

• “It’s obvious.”
• “We all agreed.”
• “It felt right.”

AI output loves justification. It’s fluent. It sounds confident. It can generate a neat rationale for anything, including things that are quietly wrong.

So if we want curation to be more than vibes, we need to make our judgement legible.

Not just to stakeholders. To ourselves. To the team two months from now. To the future version of you who has to explain this decision in a retro while your laptop fan screams like a dying pigeon (Yeah I have one of the last Intel MacBook Pros - this pain is real).

Why AI Makes Curation Unavoidable

1. Abundance Kills Signal

If output is infinite, it stops being impressive. The skill isn’t “make more”. It’s “make less, better”.

2. Quality Gets Harder To Perceive

When everything is fluent, you lose the old tells. A well-written paragraph no longer implies deep thinking. A tidy UI no longer implies a coherent interaction model. Surface polish stops correlating with underlying correctness.

3. You Can’t Review Everything

If AI speeds up creation by 10x, you don’t magically get 10x more review capacity. You get a review backlog and a creeping sense that you’re rubber-stamping.

4. Trust Becomes A Product Feature

When users are surrounded by synthetic content, they start looking for anchors: provenance, reputation, consistency, restraint. They gravitate toward sources that filter.

Curation is that filter, made explicit. And articulation is how you prove the filter isn’t random.

The Curation Loop (And The Articulation Layer Everyone Forgets)

Most teams treat curation as a moment:

• Pick an option
• Approve the copy
• Select a design direction
• Ship

But curation is a loop. It needs maintenance. It needs feedback. It needs rules that survive the week you’re on holiday.

Here’s a loop you can actually operationalise without turning your team into a bureaucracy-themed escape room.

1) Set Intent

What is this for? Who is it for? What decision should it enable?

If you can’t state intent, you can’t curate. You can only accumulate.

A useful trick: finish this sentence in plain English.
“This exists so that ____ can ____ without ____.”

If you can’t do that, you’ve got output. Not purpose.

2) Constrain The Generation

Don’t generate “everything”. Generate within boundaries that reflect reality:

• Tone and reading level
• Accessibility requirements
• Brand and legal constraints
• Domain rules (the bits that stay true even when it’s inconvenient)

Curation starts before the output appears. Constraints are pre-curation.

Constraints also reduce the temptation to treat “more options” as progress. More options is often just more avoidance.

3) Evaluate With Criteria

This is where seniority shows.

Not “which one do we like?”
But “which one meets the criteria we’re accountable for?”

Criteria that don’t collapse under pressure:

• Does it answer the user’s question without inventing new ones?
• Does it reduce cognitive load or just rearrange it?
• Is it accessible to screen readers, keyboard-only users, low vision users?
• Can support and sales explain it without freestyle interpretation?
• Does it align with the product we’re actually building, not the one we daydream about?

4) Articulate The Decision (This Is THE Bit)

This is where the articulation gap usually opens.

A decision that isn’t articulated becomes folklore, or potentially folk horror. People remember the outcome, not the reasoning. Then they rebuild the reasoning later, badly, under stress, with the swagger of a man explaining Bitcoin at a wedding.

So make the decision explicit. Not long. Not fancy. Just concrete.

Try this template:

• We chose ___
• Because ___ (the primary reason, tied to intent and criteria)
• We rejected ___ because ___ (one key alternative)
• We accept ___ (the trade-off)
• We’ll know we’re wrong if ___ (a signal you can measure or observe)

That’s curation with a spine.

It also makes AI safer to use, because you’re no longer trusting the output. You’re trusting a human decision that can be inspected.

5) Ship With Context

Curation isn’t just selecting - it’s making the choice legible.

In publishing, that looks like framing the recommendation. In products, it shows up as the things people actually experience:

• What the UI now assumes
• What the defaults nudge
• What the empty state teaches
• What the error states forgive (or don’t)
• What’s explained, and what’s quietly implied
• What happens next, without the user having to guess

So ask:

• What did we choose, and what behaviour are we now encouraging?
• What did we not choose, and where will users go looking for it anyway?
• What should the user do next, and have we made that the easiest thing to do?
• What are the limits and caveats, and are they visible at the point they matter?

Without that context, you haven’t really curated. You’ve just picked an option and left everyone to reverse-engineer the reasoning from whatever the interface happens to suggest.

6) Learn And Refine

If you don’t close the loop, your curation becomes theatre.

Track outcomes that reveal whether your selection was good:

• Did users complete the task?
• Did they need support?
• Did they trust it enough to act?
• Did they understand it the first time?

Then adjust constraints and criteria.

That’s the loop.

Curation In UX Is Already Everywhere - We Just Call It Other Things

If you work in digital products, you’ve been curating for years. You just haven’t been forced to admit it.

• Information architecture is curation with folders
• Navigation is curation with consequences
• Design systems are curated possibilities
• Content guidelines are curated language
• Search ranking is curation disguised as neutrality
• Defaults are curation on behalf of the user

AI doesn’t introduce curation to UX. It makes it visible. It turns it from a background competency into the main event.

And it raises the stakes, because AI happily generates things that are:

• Internally inconsistent
• Inaccessible by default
• Slightly wrong in a way that looks confident
• “Fine” for the happy path and catastrophic for everyone else

So the job becomes: curate reality back into the output. And then articulate that reality so others can trust it.

What Good Curation Looks Like In An AI-Heavy Workflow

Use Fewer, Better Prompts

Prompting is not the craft. Prompting is the handle.

The craft is building prompts that produce output you can reliably curate. That often means:

• Narrower scope
• Explicit constraints
• Fewer degrees of freedom
• A defined audience and reading level
• Strong negative examples (what not to do)

And then, crucially, you still articulate the decision after the output. A good prompt doesn’t remove responsibility. It just gets you to the decision faster.

Build Editorial Layers Into The Process

Think like publishing:

• Draft layer (AI is great here)
• Editorial layer (human judgement, domain knowledge)
• Fact layer (sources, references, validation)
• Accessibility layer (structure, semantics, plain language)
• Final sign-off (accountability)

If one person has to do all layers, the system will collapse. If nobody owns a layer, quality becomes vibes.

And there’s a quiet extra benefit: once you name the layers, you stop pretending “generate” and “publish” are the same activity. AI is a draft engine. Your job is to turn drafts into decisions.

Use Decision Logs To Make The Next Generation Less Stupid

Decision logs sound like governance. Like something you write to satisfy a process goblin… you know who you are goblin.

In an AI workflow they’re something else: they’re reusable judgement.

They’re civilisation in miniature. Little bundles of “we learned this the hard way” that let the next person act like they’ve already been burned once. That’s what myths, laws, and your granny’s weirdly specific rules are doing too - compressed judgement, preserved so you don’t have to re-discover gravity by falling off the roof.

In an AI workflow the “next generation” isn’t your children. It’s next week’s model, the new hire, or Future You at 16:57 (23:57, you pick your reality).

A decision log is basically a curation receipt:

• What we chose
• Why we chose it
• What we rejected
• What trade-off we accepted
• How we’ll know we were wrong

Once you have a few of those, you can start using them as input to the next round of generation.

Not in a magical “the model becomes wise” way. In a practical way:

• They turn taste into criteria the model can follow
• They capture the negative space - the patterns you keep rejecting
• They make prompts less performative
• They give you evaluation hooks

If you want logs that actually help the machine (and humans), keep them lightweight and structured. A line each is fine (you might need to go larger for bigger or more complex decisions):

• Context: what problem, who for
• Constraints: what must be true (accessibility, legal, tech reality)
• Criteria: what mattered most
• Decision: what we chose
• Rejected: one main alternative and why
• Trade-off: what we accepted
• Success signal: what would prove us wrong

After that, the loop gets more robust: decision logs stop being something you “remember to paste” and start being part of the environment. A folder. A ruleset. A default attachment in your tool. Something the model can be pointed at before it generates, and something reviewers can point to when they say “nope, we don’t do that here”.

You can still paste a few into a prompt when you’re working quickly. But the real win is when the logs sit there quietly, like guardrails, so the next round of output starts closer to your team’s actual judgement - without you having to retype your principles every time.

This won’t remove responsibility. But it will stop the model from repeatedly suggesting the same shiny mistakes, like a very confident intern who never reads the minutes.

Curate By Sampling, Not By Hope

When output volume explodes, the temptation is to do one of two things: review nothing properly, or pretend you can review everything. Both end the same way - a lot of plausible output slips through wearing a fake moustache.

Sampling is the middle path. And to be clear, this isn’t about “testing the model”. It’s about testing your curation - the standards, the gates, the human review - to see what actually gets caught when the volume goes up.

The move is simple: deliberately generate the kind of output you’d be embarrassed to publish, the plausible wrongness, and see whether your curation process stops it.

That “plausible wrongness” tends to look like:

• Confident guesses when information is missing
• Caveats quietly dropped when asked to shorten
• Accessibility requirements “accidentally” broken
• Bias sneaking in under “make it more professional”
• Overpromising what the product can do, because it sounds nicer
• Invented specificity - numbers, sources, certainty - that nobody verified

So you sample across scenarios, and you probe for those patterns on purpose. Not to create a perfect checklist, but to find the repeat offenders:

• Sample across scenarios (new user, power user, edge case, “someone doing this at 01:49”)
• Use stress prompts as curation probes - prompts designed to tempt exactly those failures, so you can see what your process misses
• Tighten the gates when something slips through - refine constraints, update decision logs, add a lightweight check, reduce degrees of freedom, change the UI so risky outputs can’t masquerade as “done”

And here’s the crucial bit: this doesn’t replace judgement - it protects it. The point of the probes and checks is to stop humans wasting their attention on the same boring failures every week, so they can spend it on the irreducible curatorial work: intent, coherence, usefulness, and what you’re willing to stand behind.

This is boring. That’s why it works.

Prefer Collections Over Feeds

In AI workflows, “feed” mode is the default: infinite variants, endless rewrites, one more prompt, one more option. It feels productive because something new keeps appearing. It’s mostly just motion.

Prefer collections instead. Make the unit of progress a finite set you can actually review, explain, and stand behind.

That might look like:

• A shortlist of 3 options, chosen against explicit criteria
• A recommended path, with the trade-off stated out loud
• A “start here” kit for your team: the prompts, constraints, and examples that reliably work
• A guided sequence for common tasks (draft - critique - tighten - check)
• A handful of proven templates you reuse, rather than reinventing the wheel every time

It’s not just easier to curate - it’s easier to maintain quality, because you’re not pretending you can review infinity.

And crucially, it signals restraint. Restraint reads as competence now.

The Leadership Angle: Curation Is How You Scale Judgement

If you’re a principal, head of design, or anyone with “lead” in your title, you’ll recognise this pattern:

• AI increases throughput
• Stakeholders ask for more variants
• Teams generate more artefacts
• Alignment gets worse, not better
• The room fills with options and empties of decisions

Your job becomes less about ideation and more about selection under uncertainty.

But here’s the bit I don’t think we say enough:

Selection isn’t the job. Defensible selection is the job.

That’s curation plus articulation.

To build this capability, you need three things.

1) Shared Criteria

Not “we know good when we see it”.

Write down the criteria. Socialise them. Use them in critique. Make them portable.

2) Decision Artefacts

Lightweight, repeatable, boring.

• Decision logs that capture the “because”
• Shortlists with explicit criteria
• Annotated examples of “good” and “not good”
• Templates that force trade-offs into the open

This is how you stop the team relying on the loudest voice in the room, or the most confident AI output.

3) Permission To Say No

Curation requires exclusion. Exclusion creates discomfort. If leadership doesn’t protect the act of excluding, you end up with a museum of “could be nice”.

In an AI world, “could be nice” is infinite. That’s the problem.

Reflection

Next time you use AI to generate options, try this:

• Generate three, not thirty
• Write the criteria before you look at them
• Pick one and write the “because” in a single sentence
• Name the trade-off out loud (yes, out loud)
• Write down how you’ll know you were wrong

If that feels harder than generating the options, good. That’s the new work.

Questions To Leave You With

• Where in your workflow has AI created more output than you can responsibly review?
• Which decisions in your team are currently made, but not articulated — and what damage does that cause later?
• What would a “decision log” look like in your world if it had to be usable, not performative?
• Which parts of your product rely on “neutral” ranking or feeds — and could benefit from explicit, human-owned curation?
• When you pick something, can you reliably say “because” without reaching for vibes?

These questions aren’t just about workflow efficiency. They’re about competitive position. In a future piece, I’ll look at why curation is becoming the differentiator in markets where everyone has access to the same generative tools - and what changes when ‘what you choose not to make’ becomes more valuable than what you ship.

If You Enjoyed This Piece

Follow me for more articles about design-driven coding, usability, and the messy, wonderful middle ground between aesthetics and logic.

Author’s Note:

I am currently deeply interested in using AI to generate both visual and text-based content. I am actively collaborating with AI on multiple platforms to explore my thoughts on what creativity is and is not.

My current approach is to collaborate with AI by using the output as a foundation upon which to build and modify.