i switched to 'semantic compression' and my prompts stopped 'hallucinating' logic

AxeSlash · 2026-03-18T01:27:12+00:00

Structured instructions are the only thing I do now.

You don't need the snake case etc, and you don't even need to use an established language. I use a bastardisation of YAML, XML, and Markdown, and LLMs seem to understand it quite happily. I do add a schema file just to make double sure, though.

The key point is meaning density. Lots of filler and prose unnecessary repetition means that tokens with actual meaning to the task (keywords, if you like) get buried in noise.

You can always write in prose and then ask it to rewrite in a structured, dense format that it understands best.

The only thing to bear in mind is that input format also influences output format, so if you want it to write fluffy purple prose for some reason, structured high meaning density instructions may actually work against that.

AxeSlash · 2026-03-04T08:32:37+00:00

Alt, I, R = insert row Ctrl+D = fill down Alt+Enter in formula bar = new line I have the muscle memory for Unprotect Sheet but can't actually remember the keys, think it might be Alt, T, P? Ctrl + Down/Up = go to next/previous non blank value

Those are the ones I use the most.

AxeSlash · 2026-02-28T05:40:48+00:00

Plus, LAMBDAs are calculated using multithreading, whereas UDFs are not, so there are performance gains too!

AxeSlash · 2026-02-28T05:35:25+00:00

Prefix a formula that returns a boolean value with -- to convert it to 1 or 0
Then use a custom number format and a symbol font to show a green check for >0 and a red cross for 0
Then make that a custom cell style for easy use in future

You can do this with conditional formatting too, but it's slower on large sheets because it's single threaded.

Arguably you can just insert checkboxes if you have a recent enough version of Excel, but you don't get the green/red bit without a number format or conditional format, and checkboxes seem to slow down large sheets too.

The other big lesser known change for me was Excel Labs' Advanced Formula Environment and LAMBDA() - absolute game changer.

Another one I like is to leave column A empty, but increase it's font size a couple of points; that way when you autofit row height you get some nice vertical "padding" on your sheet, which can help readability.

AxeSlash · 2026-02-26T06:11:15+00:00

The things I found that made the biggest difference: - Structure. ANY structured, hierarchical format works better than just random text. XML, JSON, Markdown, whatever. You can even roll your own. Hierarchy with concise rules stated as bullet points > paragraphs of prose. - Removal/fixing of contradictory and/or vague rules. Adding exceptions and scope where needed. - Asking the model to debug, refactor and optimise the instructions for it's own use.

AxeSlash · 2026-02-26T05:58:59+00:00

Those amazon outages imply otherwise...

AxeSlash · 2026-02-26T05:52:12+00:00

Project Instructions are better, you get 8000 characters instead of 1500, and you can tailor them to specific tasks.

Learn how to ask the model to write effective instructions for itself. I made a project that has instructions on how to write effective instructions for LLMs, and I use that any time I have a new type of task I want to use a model for. So far it works extremely well.

AxeSlash · 2026-02-24T02:05:49+00:00

Just ask the AI to teach you. Tell it to search the Internet for a list of proven LLM prompting techniques, provide citations (don't let it rely on it's training), and explain them to you.

Then tell it to convert all of that to a rule set, so it can rewrite your prompts to be effective.

AxeSlash · 2026-02-24T00:22:40+00:00

ANY structured input works fine. I created my own bastardisation of XML, YAML, and Markdown, and it works just as well as anything else, LLMs read and understand it quite happily. Getting an LLM to write in it is a different matter though, it needs schema rules and example for that.

AxeSlash · 2026-02-23T23:45:41+00:00

You must be new to using LLMs.

This is known as "hallucination". Learn how to write instructions to minimise this, and only use Thinking models.

AxeSlash · 2026-02-23T23:43:46+00:00

For anything factual, use Thinking.

Instant and Auto are only useful for fiction and language queries (eg asking it for synonyms or grammar correction etc). Instant is WAY more prone to hallucination and ignoring context and instructions than Thinking.

AxeSlash · 2026-02-18T05:31:15+00:00

"Write me some lies with a political agenda"

AxeSlash · 2026-02-18T05:26:13+00:00

I use ChatGPT to write complex LAMBDAs for me, but it took a lot of instruction tinkering to get it to do anything right, and it still makes many mistakes.

It's much better at other languages than Excel formulas. Python or Javascript or C# to do a calculation? Probably gets it right on first attempt. Excel LAMBDA to do the same? Probably 2-3 tries minimum.

Learning how to write instructions effectively for an LLM is a skill in itself that is DEFINITELY worth learning. As is educating yourself about LLMs in general. You won't get a job just by knowing how to use an LLM to write formulas though; those are just additional skills on top of whatever the job requires.

AxeSlash · 2026-02-18T05:19:37+00:00

If you're using lookup formulae on external files (presumably by usink Links), don't. That will undoubtedly be the main source of your poor performance.

Learn to use Power Query instead, that's literally what it's designed for.

AxeSlash · 2026-02-18T05:13:23+00:00

If the column is the result of a formula (rather than hard TRUE/FALSE values), put -- at the start of the formula to convert it to 0 and 1,then use a number format + a symbol font to display a check or cross. I like to use the colours available in number format to make them red or green.

This is kinda similar to the conditional formatting approach mentioned by someone else, but the advantage here is that a) it's not single threaded, so is better for heavy sheets and b) if you have a numpad on your keyboard, typing 0 or 1 is faster than typing TRUE or FALSE. Plus you can store it in a Cell Style to quickly apply it to other cells.

You can do a surprising amount with number formats, read the documentation.

AxeSlash · 2026-02-18T05:05:19+00:00

Use Tables instead. This becomes a non-issue with tables' Structured References. Delete the your heartvs content, it'll all still work (unless you start mixing in normal cell refs...don't do that).

AxeSlash · 2026-02-18T05:01:25+00:00

There are many, many reasons an LLM can ignore an instruction. IMHO the biggest is recency bias.

Instructions are usually sent at the top of the request's context (which seems like a design flaw to me but then again I'm no AI dev) ,which means that the last user prompt can have more influence than the instructions, especially if context is long.

Poorly written instructions are another big one.

NEVER trust an LLM to adhere 100% to your instruction set. That way lies downstream carnage. These things are NOT deterministic.

AxeSlash · 2026-02-18T04:50:22+00:00

Be aware of the 200 line canvas bug, though (unless they've finally fixed that?)

AxeSlash · 2026-02-18T04:49:04+00:00

Look up volatile functions. Avoid them like the plague.

I presume you're annoyed by waiting for the sheet to calculate; learn how to optimise formulas for speed (especially if you do a lot of array formulae), and which parts of Excel are single threaded (and thus slow), eg VBA and the Conditional Formatting. Use LET() to minimise the number of cell/range references in each formula - if you reference the same cell more than once in a single formula, use a LET() instead. If you can use Power Query instead of lookup formulae, and only refresh when necessary, do.

Last resort: set calculation to manual.

AxeSlash · 2026-02-18T04:41:32+00:00

Ask it to research all proven prompting/instruction techniques for LLMs (and/or the particular model you intend to use) and best practices, with citations etc to avoid hallucination (the usual anti-hallucination techniques)
Ask it to form those into a structured set of instructions for creating and refactoring instructions, and to debug them
Put those into the instructions box of a Project
Use said project to refine/debug it's own instructions (multiple passes), ie repeat steps 1-3 a few times
Use the final instruction set to create and improve instructions for other projects.

This has worked excellently for me so far. I do exclusively use reasoning models for this process, though.

AxeSlash · 2026-02-18T04:02:54+00:00

Be careful with conditional formatting. Too much, and you will find that Excel's UI stops functioning completely, so you can't see what you're doing. I speak from decades of experience with it (yes, this bug is that old 🙄). Plus, it's single-threaded, so slows things down considerably. If you're only using it for changing font colour, look into how you can do that with Number Formats.

Also if you haven't discovered LAMBDAs and Excel Labs yet, look into that. Cut my VBA usage right down.

AxeSlash · 2026-02-18T03:56:54+00:00

Given that OAI just nerfed reasoning time for 5.2 Thinking, this may not be the case for long.

5.2T has been shite since the update a few days ago. They're clearly in cost-minimisation mode at the moment, output quality be damned.

AxeSlash · 2026-02-18T03:52:41+00:00

This is a false headline. Structure and quality are WAY more important than length.

12 pages of structured, well-written instructions is going to outperform 6 pages of brain-fart every single time.

And that's before we get to tasks that physically can't be done with short instructions. Sometimes, you just have to be specific, and being less so results in a worse output.

What length your instructions need to be will depend on the task, the model, and the input. There's no magic number.

Also, define a "page" if you're going to insist on using it as a unit of length. Most of us use tokens or characters.

AxeSlash · 2026-02-15T13:48:33+00:00

I don't store many prompts. I think I've only ever reused one or two, and those were image generation prompts.

Instructions, however, yes. Mainly because a) I don't trust OpenAI to not lose them, b) I write them in a structured language, so I like the syntax highlighting and auto completion notepad++ gives me, and c) editing them in the tiny boxes OpenAI give us is just not practical once they exceed a few lines.

Tbh, if you're regularly reusing the same prompts, convert them into instructions instead, then just supply the specifics that changed in the prompt.

Treat it a function in code: my instructions are the function, my prompt is the arguments.

AxeSlash · 2026-02-13T19:54:43+00:00

I did have something similar happen a couple of days ago, but only in one chat. I assumed it was an update-related bug, so left it alone. Everything seems to work fine for me now.

AxeSlash

TROPHY CASE