(See also the famous Pascal quote “This would have been a shorter letter if I had the time”).
P.s. for reference I’ve asked an LLM to compress what I wrote above. Here is the output:
When I have a murky idea that’s hard to articulate, I find it helpful to ramble—typing or dictating a stream of semi-structured thoughts—and then ask an LLM to summarize. It often captures what I mean, but more clearly and effectively.
Elsewhere in this comment section, it's discussed about the importance of having original thought, which the summarized text specifically isn't, and has leeched away.
The parent comment has actually made the case against the summarized text being "better" (if we're measuring anything that isn't word count).
An LLM could make something sound articulate even if your input is useless rambling containing the keywords you want to think about. Having someone validate a lack of thought as something useful doesn't seem good for you in the long term
Learning how to condense what I say focuses me to think about what is and isn't important - and it also forces me to think in terms of "style" and "audience".
(My natural writing style is much more verbose - I want to address all sorts of branching objections and tangential concepts. I find parenthesis really useful, because I can dump a bunch of stuff there and it's a clear marker that you can safely skip it all)
LLMs are also useful, because I can ramble, work out my own summary, and then compare to the LLM. Or, when I was just starting out, ramble, get an LLM to summarize, and then try to work out my own summary that captures what it missed.
Aside from practice being inherently beneficial, I also find that being able to form my own summaries helps me catch when the LLM has misunderstood, hallucinated, or just subtly changed the emphasis - for instance, your original example was indeed much cleaner, but I wouldn't have felt like you were really truly a fellow rambler just from reading that.
Hopefully you don't mind a rambling post. If you want a TL;DR an LLM can probably do a decent job ;)
(ChatGPT Summary: Practicing summarization improves clarity, audience awareness, and writing focus—especially for naturally verbose thinkers. LLMs are helpful tools for this, both as a comparison point and a learning aid. Writing your own summaries sharpens understanding and helps catch LLM misinterpretations or emphasis shifts.)
(Yeah, that seems pretty accurate)
Done, now ai is just lossy prettyprinting.
I have it write doc strings. I later ask it to explain a section of code, wherein it uses the doc strings to understand and explain the code to me.
A less lossy way to capture this will probably emerge at some point.
It's much more useful for answering questions that are public knowledge since it can pull from external sources to add new info.
Ideally there's some selection done, and the fact you're receiving it means it's better than a mean answer. But sometimes they haven't even read the LLM output themselves :-(
At some point we will stop making decisions about what future readers want. We will just capture the concrete inputs and the reader's LLM will explain it.
A piece of text does not have a single inherently correct interpretation. Its meaning is a relation constructed at run- (i.e. read-)time between the reader, the writer, and (possibly) the things the text refers to, that is if both sides are well enough aligned to agree on what those are.
Words don't speak, they only gesture.
What if we could persist this final LLM context state? Think of it like a queryable snapshot of the 'why' behind code or docs. Instead of just reading a comment, you could load the associated context and ask an LLM questions based on the original author's reasoning state.
Yes, context is model-specific, a major hurdle. And there are many other challenges. But ignoring the technical implementation for a moment, is this concept – capturing intent via persistent, queryable LLM context – a valuable problem to solve? I feel it would be.
What about a tool that simply allows other developers to hover over some code and see any relevant conversations the developer had with a model? Version the chat log and attach it to the code basically.
So perhaps switching to open-source models of sufficient "power" will obsolete that particular concern (they would be a "development dependency", just like a linter, compiler or code formatter are today).
as long as the text isn't at risk of being written up by HR, I don't particularly care about the tone of the message.