Here are some of my experiences:
* Figuring out where to start when learning new things (see also
https://news.ycombinator.com/item?id=43087685>)
One way I treat LLMs is as a "semantic search engine". I find that LLMs get
too many things wrong when I'm being specific, but they're pretty good at
pointing me in a general direction.
For example, I started learning about OS development and wanted to use Rust. I
used ChatGPT to generate a basic Rust UEFI project with some simple
bootloading code. It was broken, but it now gave me a foothold and I was able
to use other resources (e.g. OSDev wiki) to learn how to fix the broken bits.
* Avoiding reading the entire manual
It feels like a lot of software documentation isn't actually written for real
readers; instead being a somewhat arbitrary listing of a program's features.
When programs have this style of documentation, the worst case for figuring
out how to do a simple thing is reading the entire manual. (There are better
ways to write documentation, see e.g. )
One example is [gnuplot](http://www.gnuplot.info/). I wanted to learn how to
plot from the command line. I could have pieced together how to do it by
zipping around the
[gnuplot manual](http://www.gnuplot.info/docs_5.4/Gnuplot_5_4.pdf) and building
something up piecewise, but it was faster to instruct Claude directly. Once
Claude showed me how to do a particular thing (e.g. draw a scatter plot with
dots intstead of crosses) I then used the manual to find other similar
options.
* Learning a large codebase / API
Similar to the previous point. If I ask Claude to write a simple program using
a complex publicly-available API, it will probably write a broken program, but
it won't be *completely* bogus because it will be in the right "genre". It
will probably use some real modules, datatypes and functions in a realistic
way. These are often good leads for which code/documentation I should read.
I used this approach to write some programs that use the
[GHC API](https://hackage.haskell.org/package/ghc). There are hundreds of
modules, and when I asked Claude how to do something with the GHC API it wrote
relevant (if incorrect) code, which helped me teach myself.
* Cross-language poetry translation
My partner is Chinese and sometimes we talk about Chinese poetry. I'm not very
fluent in Chinese so it's hard for me the grasp the beauty in these poems.
Unfortunately literal English translations aren't very good. We've had some
success with asking LLMs to translate Chinese poems in the style of various
famous English poets. The translation is generally semantically correct, while
having a more pleasing use of the English language than a direct translation.