Update README with a motivations paragraph

Replace ASCII art with bullet points

Author: ncw

README.md

@@ -1,12 +1,24 @@
 # ccforth
 
 ccforth is a Forth to C compiler written in Go. It interprets
-compile-time Forth (immediate words, metaprogramming) and emits
+compile-time Forth (immediate words, meta-programming) and emits
 flattened C11 code that is compiled with gcc or clang to produce
 standalone executables.
 
 - GitHub: https://github.com/ncw/ccforth
 
+ccforth was written to explore the idea of having an interpreter and a
+compiler running simultaneously to enable meta-programming heavy Forth
+programs to be compiled into C. This is harder than it sounds because
+Forth cannot be ahead-of-time compiled by parsing alone; programs
+routinely execute code at compile time. The project was also an
+experiment in how far an AI agent could progress a compiler project -
+most of the initial implementation was done by Claude Opus 4.6. Go was
+used as the implementation language as it is low enough level to
+express Forth properly but easier to write than C. C was used as a
+compiler backend as C compilers optimize well and are available
+everywhere.
+
 ## Features
 
 - **Fast compiled output** — generates optimised C11, compiled with
@@ -44,28 +56,16 @@ standalone executables.
 
 ## How it works
 
-```
- .fth source
-      |
-      v
-+-----------+   +-------------+   +--------------+
-|  Scanner  |-->| Interpreter |-->|  C Emitter   |
-|  (lexer)  |   | (executes   |   | (generates   |
-|           |   |  immediate  |   |  flattened C |
-|           |   |  words,     |   |  from word   |
-|           |   |  builds     |   |  bodies)     |
-|           |   |  dictionary)|   |              |
-+-----------+   +-------------+   +------+-------+
-                                        |
-         self-contained output.c <------+
-          (runtime inlined)
-                      |
-                      v
-              gcc / clang (C11)
-                      |
-                      v
-              standalone executable
-```
+1. **`.fth` source** is read by the **Scanner** (lexer), which
+   tokenises it.
+2. The **Interpreter** executes immediate words and metaprogramming,
+   building a dictionary of word bodies.
+3. The **C emitter** walks the finished dictionary and generates
+   flattened C from the word bodies.
+4. The result is a self-contained **`output.c`** with the runtime
+   inlined.
+5. **gcc / clang** compiles that C11 source into a **standalone
+   executable**.
 
 Forth source is processed by the **interpreter**, which executes
 immediate words (like `IF`, `DO`, `:`, `;`) and allows the normal