What AI Is Good & Bad At

Under the hood, today's generative models are pattern machines. An LLM predicts likely next words; an image model denoises toward a likely picture. They have absorbed staggering volumes of human text and images, so their sense of 'what usually comes next' is extraordinary. That is the whole source of their strengths - and it maps precisely onto tasks that are about fluency and volume rather than truth and judgement.

So AI is genuinely excellent at:

+ SPEED       seconds, not hours
+ VOLUME      fifty options while you think
+ DRAFTING    a first version you react to and fix
+ SUMMARISING compressing long documents to their gist
+ PATTERNS    spotting structure in messy data
+ AUTOMATION  tireless repetition without boredom

Notice what these share: in every case a fast, imperfect, plentiful output is useful, because you are going to shape it afterwards. A first draft you rewrite is worth more than a blank page. Fifty concept images you cull to three beat the four you would have sketched. A summary you spot-check saves an hour of reading. The value is real precisely where being 'roughly right and instantly available' beats being 'perfect and slow.' This is the productive half of the mental model, and it is why refusing to use AI at all is its own kind of mistake.

It is worth being concrete about how large these strengths are, because it is easy to under-rate them out of caution. An LLM can compress a hundred-page report into a page you can act on in the time it takes to fetch coffee. An image model can put forty material-palette variations in front of you before you would have finished sketching one. A summary of client feedback that would take an afternoon to collate emerges in a minute, ready for you to correct. None of this is truth on tap - but all of it is a serious multiplier on the parts of design that are about generating, drafting and digesting rather than deciding. Used on the right tasks, that multiplier is transformative, and dismissing it as mere hype is as mistaken as believing the machine can design.

The same pattern-matching that powers the strengths creates the weaknesses - they are two faces of one mechanism, not a list of bugs to be patched away. A model optimised for plausibility has no separate faculty for truth, no stake in the outcome, and no access to your actual situation. So it is unreliable at:

Truth and accuracy. Models hallucinate: they generate confident, fluent, entirely false statements - a fabricated code clause, a citation to a paper that does not exist, a product with invented specs. Crucially the false output looks exactly like the true output. There is no tell in the text itself. This is the single most important limit to internalise.

Judgement of good versus merely plausible. AI can produce a competent design or argument; it cannot reliably tell you whether it is good - appropriate to this client, this site, this budget, this brief. That discrimination is the core of design and it stays yours.

Real context. The model was not at the site visit, did not feel the afternoon glare, does not know the client's marriage is strained or that the local authority is unusually strict. It knows the average of the internet, not your particular case.

Accountability. When a spec is wrong on site, a person carries the professional and legal responsibility. A model cannot. It has nothing to lose, so it cannot be trusted the way a responsible colleague can.

Genuine novelty. Because it interpolates from what exists, AI trends toward the average and the already-seen. It can recombine surprisingly, but true originality - the leap that defines memorable design - is not its strong suit. It is also prone to bias inherited from its training data, which quietly pushes output toward the conventional.

The deepest point about all five is that they are not going to be patched out by a bigger model, because they are properties of the approach, not defects in a particular product. A system whose entire objective is to produce plausible continuations has no internal sense of whether a continuation is true, good, appropriate to your case, or genuinely new - those judgements require a stake in the outcome and a grasp of the real situation that the model does not have and cannot acquire from more data. Newer models will be more fluent and often more accurate, which paradoxically makes their remaining errors harder to spot, because the surrounding prose is so convincing. So the safe professional stance is not suspicion of AI, but a permanent, calm awareness of exactly which faculties it lacks - and a workflow arranged so that a human supplies them.

Put the two halves together and you get a simple instrument for the decision you actually face: should I reach for AI on this task, and if so, how hard must I check it? Two questions settle it.

Is the task divergent or convergent? Divergent tasks open up possibilities (ideation, mood, options, first drafts); convergent tasks close down to one correct answer (a code check, a dimension, a spec, a figure). AI is a natural fit for divergent work - volume and speed are exactly what you want - and a hazard on convergent work, where a plausible-wrong answer is worse than none.

What are the stakes if it is wrong? A dud moodboard costs a click. A wrong fire-egress width costs lives and your licence. The higher the stakes, the more the burden of proof shifts onto you.

Cross those two and you get four zones: divergent and low-stakes (reach freely, curate hard, check lightly); convergent but low-stakes (let AI draft, skim before use); divergent but high-stakes (wide input, tight human selection); and convergent and high-stakes (use AI if it helps, but verify every claim to source - or just do it yourself). The tool is the same in all four; only your level of trust changes. Getting fluent at reading which zone a task sits in - often in a second, without thinking - is what separates confident AI-assisted designers from anxious ones.

The two mistakes this model guards against are opposite and equally common. One is the over-truster, who lets a confident answer settle a convergent, high-stakes question - the person who pastes an AI-summarised code clause straight onto a drawing and discovers on site that it was invented. The other is the blanket-refuser, who has heard AI 'makes things up' and therefore will not use it even to brainstorm or draft, forfeiting a genuine advantage on exactly the divergent work where a wrong answer costs nothing. Both have failed to read the zone. The model is not 'trust AI' or 'distrust AI'; it is 'trust AI this much on this task', with the dial set by divergence and stakes rather than by mood or hype. Once that becomes automatic, most of the day-to-day fear around AI simply evaporates, because you always know how much weight the output is allowed to carry.

The real art is designing your workflow so AI's strengths carry the load and its limits never get the last word. A few durable moves:

Use AI to draft, keep the truth-check human. Let it write the first pass of a spec, a proposal, a code summary - then you verify the facts against the actual source. You get the speed of a draft without inheriting its errors. A useful prompt habit is to make checking easier:

Summarise the attached fire-safety chapter for a small office. For every
requirement, quote the exact clause number and the line it comes from, so
I can verify each against the source. If a detail is not in the text, say
"not stated" rather than guessing.

That last instruction does not stop hallucination, but it makes fabrication easier to catch and gives you the anchors to check.

Use volume for divergence, judgement for convergence. Generate widely when you are opening a problem up; switch to slow, careful human decision the moment you are closing it down.

Treat authoritative-looking output most sceptically. A confident number, a clean citation, a precise-sounding clause - these feel trustworthy and are exactly where hallucination hides. The polish is not evidence.

Ask what only you can bring. Before accepting any output, ask: does this reflect the real client, site and brief - the context the model never had? That question alone catches most of the failures that matter, and it keeps you the author. Modules 9.1 and 9.2 turn these instincts into rigorous evaluation and hallucination-catching routines.