[lightandlight]

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. <https://diataxis.fr/>)

  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.