From 21463ede20ca418cc53113243a5ce9e1e0772e22 Mon Sep 17 00:00:00 2001 From: Danila Fedorin Date: Sun, 5 Apr 2026 15:42:26 -0700 Subject: [PATCH] Make some edits. Signed-off-by: Danila Fedorin --- content/blog/pdf_flashcards_llm/index.md | 44 ++++++++---------------- 1 file changed, 15 insertions(+), 29 deletions(-) diff --git a/content/blog/pdf_flashcards_llm/index.md b/content/blog/pdf_flashcards_llm/index.md index cab67f2..e7fcef4 100644 --- a/content/blog/pdf_flashcards_llm/index.md +++ b/content/blog/pdf_flashcards_llm/index.md @@ -254,22 +254,12 @@ With LLMs, I was able --- allowed? --- to view things more so from the end-user perspective. I didn't know, and didn't need to know, the API for `PyMuPDF`, `argostranslate`, or `spaCy`. I didn't need to understand the PDF format. I could move one step away from the nitty-gritty and focus -on the 'why' and the 'what'. - -The boundary between 'manual' and 'automatic' was not always consistent. -Though I didn't touch any of the PyMuPDF code, I did need to look fairly -closely at the logic that classified my squiggles as "underlines" and found -associated words. In the end, though, I was able to focus on the core -challenge of what I wanted to accomplish (the inherent complexity) and -avoid altogether the unrelated difficulties that merely happened to be +on the 'why' and the 'what', on the challenge of what I wanted to accomplish. +I wrestled with the inherent complexity and +avoided altogether the unrelated difficulties that merely happened to be there (downloading language modules; learning translation APIs; etc.) -This was true even when I was writing the code myself. Codex created the -word-highlighting utility in one shot in a matter of seconds, saving -me probably close to an hour of interpreting the algorithm's outputs -while I iterated on the proper heuristic. - -By enabling me to _do_, the LLM let me make rapid progress, and to produce +By enabling me to do this, the LLM let me make rapid progress, and to produce solutions to problems I would've previously deemed "too hard" or "too tedious". This did, however, markedly reduce the care with which I was examining the output. I don't think I've _ever_ read the code that produces the @@ -279,17 +269,8 @@ I think that this has to do, at least in part, with different views on code as a medium. #### The Builders and the Craftsmen -AI discourse is nothing new; others before me have identified a distinction -between individuals that seems to color their perspective on LLMs. Those -that appreciate writing software as a craft, treating code as an end -in and of itself (at least in part), tend to be saddened and repulsed by -the advent of LLMs. LLMs produce "good enough" code, but so far it -lacks elegance, organization, and perhaps, care. On the other hand, -those that treat software as a means to an end, who want to see their -vision brought to reality, view LLMs with enthusiasm. It has never been -easier to make something, especially if that something is of a shape -that's been made before. - +There are two perspectives through which one may view software: +as a craft in and of itself, and as a means to some end. My flashcard extractor can be viewed in vastly different ways when faced from these two perspective. In terms of craft, I think that it is at best mediocre; most of the code is generated, slightly verbose and somewhat @@ -305,7 +286,7 @@ capable of being any combination of these two camps at any given time. Indeed, different sorts of software demand to be viewed through different lenses. I will _still_ treat work on my long-term projects as craft, because I will come back to it again and again, and because our craft has evolved -and to engender stability and maintainability. +to engender stability and maintainability. However, I am more than happy to settle for 'underwhelming' when it means an individual need of mine can be addressed in record time. I think this @@ -332,7 +313,7 @@ the number of features it provides. Suppose also that individual users leverage only a small subset of the software's functionality. From these assumptions it would follow that individual programs, made to serve a single user's need, would be significantly less complicated than the "whole". -By definitions, these programs would also be better tailored to the users' +By definition, these programs would also be better tailored to the users' needs. With LLMs, we're getting to a future where this might be possible. I think that my flashcard generator is an early instance of such software. @@ -373,7 +354,7 @@ if I had to give a rough heuristic, it would be problems that: * __have relatively low stakes__, again, because LLMs are not perfect, and nor is (necessarily) one's understanding of the problem. * e.g., it's OK if I miss some words I underlined; my cash flow - charts only give me an impression of my spending; + charts only give me an impression of my spending; * I recognize that moving files is a potentially destructive operation. I dream of a world in which, to make use of my hardware, I just _ask_, @@ -393,12 +374,17 @@ to hit the ground running, to know what to ask and to help pluck out a particula solution from the space of various approaches. I think that this greatly accelerates the effectiveness of using LLMs compared to non-technical experts. +For another, the boundary between 'manual' and 'automatic' is not always consistent. +Though I didn't touch any of the `PyMuPDF` code, I did need to look fairly +closely at the logic that classified my squiggles as "underlines" and found +associated words. It was not enough to treat LLM-generated code as a black box. + Another advantage software folks have when leveraging LLMs is the established rigor of software development. LLMs can and do make mistakes, but so do people. Our field has been built around reducing these mistakes' impact and frequency. Knowing to use version control helps turn the pathological downward spiral of accumulating incorrect tweaks into monotonic, step-wise improvements. -Knowing how to construct a test suite and thinking about edge cases cap +Knowing how to construct a test suite and thinking about edge cases can provide an agent LLM the grounding it needs to iterate rapidly and safely. In this way, I think the dream of personal software is far from being realized