You Can't Prompt Your Way Out of a Hard Constraint

Thursday morning I removed five nodes from my content pipeline. By lunch I understood something about building with language models that eleven failed edits had been trying to teach me all week: when a rule absolutely has to hold, you don't write the rule into the prompt. You enforce it in code.

This is a field report from the inside of the AI content engine I built in n8n. It's not a hot take about prompt engineering. It's the specific, expensive way I learned where prompts stop working — and what to do instead.

ConnectEngine OS has a module called ContentFlow. You give it a topic, it grounds itself in real sources, and it writes platform-specific posts: a blog draft, a LinkedIn version, an X version, Facebook, Instagram, plus a matching image prompt. One idea in, six shaped outputs out.

For weeks there had been a verifier stage in the middle — a fact-check node that re-read every claim against the cited sources. It was slow and it was noisy, so on Thursday I split it out and removed it from the generation path. The workflow went from 36 nodes to 31. Cleaner. Faster. Then I regenerated an idea to smoke-test the change, and every platform output came back wrong.

X was over 5,000 characters against a 270 limit. LinkedIn and Instagram had markdown #

headers that those platforms explicitly don't render. Everything read like a blog post regardless of which platform it was for. The image prompt field was stuffed with the article body instead of a visual description. When I checked the backlog, 21 of 45 ideas were affected — 47% of everything in the pipeline.

My first reaction was the wrong one: what did removing the verifier break?

It hadn't broken anything. The verifier removal was innocent. What it did was stop hiding a bug that had been there the whole time.

Here's the part that matters. The node that calls the model assembles a system prompt that's roughly 49KB. That's not a typo. It's the platform's format rules, plus the full grounding context — the primary source (~6KB), three separate search-result bodies (~4KB each), the citation-formatting rules, the founder voice profile, and the per-platform instructions. All concatenated into one instruction block.

Inside that 49KB sits a single line that says, in effect, "X posts must be under 270 characters, no markdown headers." And the model ignores it.

Not maliciously. The grounding context is the overwhelming bulk of those tokens, and it's full of concrete, specific article content. A single formatting sentence floating in that ocean doesn't get the model's attention. The signal is swamped.

The actual root cause was even more direct: an upstream node was writing each idea's raw_idea

as an imperative instruction ("write a comprehensive guide to..."), and that instruction was passed verbatim into the user message. The model obeyed the imperative it was handed over the format rules buried in the system prompt. Same story for the image prompt — it was told to write an article, so it wrote an article into the image field.

So I did what most people do. I tried to fix it with better instructions.

| Fix attempt | Mechanism | Outcome |

|---|---|---| | Topic-reframe in the user message | prompt | Partial — stopped the imperative echo, lengths still wrong |

| End-of-prompt "final reminder" with hard char limits | prompt | Partial — LinkedIn 4550 → 2896, Facebook 1789 → 691, but X and LinkedIn still over |

| "Default to a single tweet, not a thread" rule | prompt | Ignored — still produced a 3-tweet thread |

| "Don't write source stories in the first person" rule | prompt | Ignored — still wrote a borrowed "$257/month" story as mine |

| Re-splitter: break long output into ≤270-char tweets at sentence boundaries | code | Works — X is postable no matter what the model emits |

| Character gate with an X exemption | code | Works |

| Brand-aware image fallback (read brand config, build the prompt from a template) | code | Works — images stay on-brand even when generation misfires |

| Image guard: discard anything with #

headers or over 400 chars | code | Works — article bodies never reach the image field |

Read that table top to bottom. Every prompt-level fix was partial or flatly ignored. Every code-level fix worked the first time and kept working.

By the eleventh edit I stopped pretending the next instruction would be the one that stuck. The lesson wasn't "write the rule more forcefully." The lesson was that I'd been using the wrong tool for the job.

Zero out of eleven on one side. Four out of four on the other. When the data is that lopsided, it isn't telling you to try harder. It's telling you the category is wrong.

Here's the rule I walked away with, and it's now how I build every model-backed feature:

Use the prompt for the generative task. Use code for the hard constraints.

The prompt decides what to write about, the voice, the tone, the angle. That's what language models are extraordinary at, and you should let them cook. But the moment a requirement must hold — a character limit, a banned markdown token, a brand color in an image, a field that must never contain an article body — that requirement does not belong in the prompt. It belongs in a post-processor, a re-splitter, a deterministic truncation at a sentence boundary, a validation gate, a template you interpolate into. Something that runs in code, after the model, and cannot be argued with.

This is the same shape as a lesson I keep relearning across the whole product. When I rewrote 16 plan documents from scratch, the takeaway was "plans rot faster than code because plans have no CI." A prompt instruction is a plan. Code is the CI. If the constraint has no enforcement below the layer that can ignore it, it will eventually be ignored.

I'm not going to pretend it's all solved. Five of six platforms post correctly now and the images came out genuinely good — idea-specific and on-brand. But: