Sample Use Cases
LLMs are increasingly here to stay despite the reservations . How can I use them to enhance my capabilities?
Look out for the Gell-Man amnesia effect. You prompt the LLM on some subject you know well. You read the response and see the LLM has absolutely no understanding of either the facts or the issues. In any case, you read with exasperation or amusement the multiple errors in the response, and then ask it about something else, and read the response as if it’s more accurate than the baloney you just read.
Building complete applications, e.g., a trivia-like game with Python’s Flask web server. Makes it cheap to prototype in cases where the technology behind the prototype matters much less than the content or problem being solved.
As a tutor for new technologies/framework. Although React might be new to you, it’s not new to other people. Something that probably exists in some tutorial somewhere, e.g., blinking an LED on a Raspberry Pi.
For monotonous tasks, e.g., taking unstructured data and formatting it into a structured format, citing web pages, etc.
Make every user a “power user”, e.g., hooking up an LLM into emacs to automate transforming code snippets: C-h C-h rewrite these #defines to a dictionary of {keycode: string, …}.
As an API reference. Write a latex command \red{} that turns the text red.
lldb “i r” equivalent. What does this do: find . -name '*txt' -exec bash -c ' mv $0 ${0/\ZZ_/}' {} \;.
To search for things that are hard to find. For traditional search engines, it
seems like you’re trying to use keywords that the answer will have and not the
question. So I know that + corresponds to __add__ but what is ~?
To solve one-off tasks. These are disposable programs where cleanliness doesn’t
matter. I have a .jsonl file (JSON object on each line). Each line has a key
called “text”, along with some other I don’t care about. Can you write a
function to extract the string on each line in python? In bash every second
write the memory usage and average CPU usage to a file.
To explain things. While LLMs are not as knowledgeable as the best person in the world, there are thousands/millions of people who know answers to the questions that I have, and so the LLMs probably have the answer too. What does this mean 60mW/sr @ 100mA LLMs are useful in grounding you in the rough shape and jargon of a field; use them as a starting point for building an accurate mental model of how the field works; treat LLMs as just one unreliable source of information. #knowing
To solve tasks with known solutions. Can you help me convert this python
program into a C program that does the same thing but is faster? Rewrite this
function in rust. mp.Pool parallelize this with 128 jobs across the size of
the file.
Skill as a code reviewer comes in handy. Can you tell when the LLM is hallucinating or inaccurate? If I don’t know Rust, how can I be confident that the program is correct?
To fix common errors. Ask LLM “How do I fix this error? [error]”; apply step-by-step solution as suggested by LLM; if it does not work, say “that didn’t work”.
Whenever the AI gives a fix but you don’t understand why, ask, e.g., can you explain why that change solves the problem? That way, you learn for next time, and can double check that the AI’s reasoning is sound.
IIRC, chain of thought explanations are inferred after the fact. How much weight should I give them given that they’re, in a sense, predetermined? Maybe they give enough pointers for me to verify elsewhere on their plausibility/accuracy?
Converse with the rubber duck, e.g., I will explain what this function is doing: [your explanation]. Given that, is my reasoning correct and does it reveal where the bug is?
To create structured output while also reasoning, try a 2-step approach, e.g.,
- Prompt 1: Do {the thing described in detail}. End with a clear summary of your answer that includes {things you need for JSON}.
- Prompt 2: *A previous agent said {content}. Structure as JSON according to {schema}. Use {tool} to validate the JSON.
Prompting Techniques
I don’t like the term “prompt engineering” because there’s not a lot of science and reproducibility behind it. Evals are the standard for evaluating prompts, but a lot of the advice out there does not come with evidence of evals.
Provide context, e.g., I have a Node.js function using Express and Mongoose that should fetch a user by ID, but it throws a TypeError. Here’s the code and error… VS Code has an improved UX where the LLM can search the codebase’s index to select potentially relevant context to include in the prompt ( notes ).
Seems like the goal is to provide context that the LLM might not infer by itself, e.g., the fact that we’re using Express and Mongoose.
Maybe I should think of it as trying to navigate a massive probability space? Given this much context, what is the probability of generating a useful/plausible response? We don’t want to sample from the universe of where everything is possible.
Be specific about your goals, e.g., How can I improve the performance of this sorting function for 10k items? {{ code }}.
Break down complex tasks into smaller chunks and iterate, e.g., Outline a plan
to add a search feature that filters a list of products by name in my React app.
The products are fetched from an API. Refine the plan. Okay, implement step 1:
create a SearchBar component with an input that updates a searchQuery
state. And so forth, iterating where need be.
Include examples of expected behavior, e.g., Given the array [3, 1, 4], this function should return [1, 3, 4]. Conventionally referred to as few-shot prompting.
Leverage roles or personas, e.g., You are a JavaScript performance expert. Optimize the following function for execution speed. Role prompting (e.g., You are an expert doctor, help me with this rash I have all over.) doesn’t trump giving the right context (e.g., pt presents w bilateral erythema, need diff dx). Others have noted that telling the LLM that someone else wrote something and you need their help assessing the quality of it makes the LLM more cutthroat and direct instead of sycophantic and deferential.
Iterate and refine the conversation, e.g., That solution uses recursion, but
I’d prefer an iterative approach – can you try again without recursion?
Actually, in our app we use a custom hook useProducts() that already handles
fetching. Please refactor to use useProducts instead of directly calling
fetch.
Keep a high quality bar because the LLM will anchor on the snippets and context provided. If coding fast and loose to get something working, might want to disable LLM completions because “garbage in, garbage out” applies.
From Technical Debt to Cognitive and Intent Debt
Technical Debt
How code structure and implementations make systems harder to change; arises when devs make tradeoffs that prioritize short-term delivery over long-term quality.
At the same time, the GenAI shows great promise for reducing tech debt through automated refactoring, test generation, and automated code review.
Cognitive Debt
Erosion of shared understanding across a team where no one can confidently explain how a system works or predict the impact of a change.
Before GenAI, the friction of writing code forced a partial mental model, even when the implementation was imperfect. Adopting GenAI outputs with minimal scrutiny accumulates cognitive debt invisibly. Effective problem solving requires continuous interaction between a developer’s model of the problem and their model of the system, each informing and correcting the other.
Symptoms of cognitive debt: resistance to change; unexpected results from a change; unpredictable onboarding; losing track of who knows what; very few people who truly understand the system.
Cognitive debt can be mitigated by: designing for troubleshooting; re-implementation to repair cognitive debt as cost of code generation is low; system walkthroughs; retrospectives and postmortems when challenges arise.
Treat shared understanding as a first-class deliverable, something the team invests in explicitly rather than something that happens as a side effect of writing code.
Beware of practices that produce artifacts of understanding without hard cognitive work to build the mental models, e.g., using GenAI to produce explanations of what the system does. There is human friction involved in understanding, and it shouldn’t be automated away.
Others have phrased cognitive debt as a risk to be managed. Some have pointed out the understanding is often not needed at all, similar to how managers have always had to trust team members.
Intent Debt
Absence of clear goals, constraints, and rationale that explain what the system is for and guide how it should evolve.
Practices that capture intent, e.g., specifications, tests, domain knowledge, design rationale, might resurge.
Diagnosing intent debt: system’s behavior drifts from what stakeholders expect; AI agents struggle to make changes; non-functional requirements, e.g., perf budgets, are known to fewer people.
Strategies for creating and maintaining intent artifacts: executable intent, e.g., behavior-driven development (BDD) specs and tests; recording architectural design records; domain-driven design; engineering the LLM harness to reduce AI frustration; AI-assisted intent capture from meetings and conversations; keep user needs visible and revalidate them frequently against real user feedback and outcomes.
References
- How I Use 'AI'. Nicholas Cartini. nicholas.carlini.com . Aug 1, 2024. Accessed Dec 24, 2024.
- How I Use 'AI' | Hacker News. news.ycombinator.com . Accessed Dec 24, 2024.
- The Prompt Engineering Playbook for Programmers. Addy Osmani. addyo.substack.com . May 27, 2025. Accessed Jun 4, 2025.
- Prompt engineering playbook for programmers | Hacker News. news.ycombinator.com . Accessed Jun 4, 2025.
- Gell-Mann amnesia effect - Wikipedia. en.wikipedia.org . Accessed Jun 8, 2025.
- Prompt engineering for Copilot Chat. code.visualstudio.com . Accessed Jun 3, 2025.
- From Technical Debt to Cognitive and Intent Debt. Rethinking software health in the age of AI. Margaret-Anne Storey. spawn-queue.acm.org . Accessed Jun 11, 2026.
Advice in On Learning applies here.