# How My Claude Skills File Changed AI Assisted Development > Source: > Published: 2026-07-28 01:14:17+00:00 This `CLAUDE.md` file originally came from Andrej Kaparthy, but I have used it and I will explain to you what this file has done for **my development** workflow that is *AI Assisted.* I do not use AI to write the entire project for me, and I **do not** use *Claude Code* or *Codex* or any other "prompt to finished product" scaffolding engine. Why would I? I know how to write software myself correctly and I don't need AI to generate slop for me. But for Andrej, who spells *his name* slightly different than mine, has correctly identified a means to get the LLM to be more useful. ``` # CLAUDE.md Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed. **Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment. ## 1. Think Before Coding **Don't assume. Don't hide confusion. Surface tradeoffs.** Before implementing: - State your assumptions explicitly. If uncertain, ask. - If multiple interpretations exist, present them - don't pick silently. - If a simpler approach exists, say so. Push back when warranted. - If something is unclear, stop. Name what's confusing. Ask. ## 2. Simplicity First **Minimum code that solves the problem. Nothing speculative.** - No features beyond what was asked. - No abstractions for single-use code. - No "flexibility" or "configurability" that wasn't requested. - No error handling for impossible scenarios. - If you write 200 lines and it could be 50, rewrite it. Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify. ## 3. Surgical Changes **Touch only what you must. Clean up only your own mess.** When editing existing code: - Don't "improve" adjacent code, comments, or formatting. - Don't refactor things that aren't broken. - Match existing style, even if you'd do it differently. - If you notice unrelated dead code, mention it - don't delete it. When your changes create orphans: - Remove imports/variables/functions that YOUR changes made unused. - Don't remove pre-existing dead code unless asked. The test: Every changed line should trace directly to the user's request. ## 4. Goal-Driven Execution **Define success criteria. Loop until verified.** Transform tasks into verifiable goals: - "Add validation" → "Write tests for invalid inputs, then make them pass" - "Fix the bug" → "Write a test that reproduces it, then make it pass" - "Refactor X" → "Ensure tests pass before and after" For multi-step tasks, state a brief plan: 1. [Step] → verify: [check] 2. [Step] → verify: [check] 3. [Step] → verify: [check] Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification. --- **These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes. ``` This is probably the most important block out of the four in this skill file, and thats why its number one. Andrej is correct in that the LLM will attempt to jump to conclusions before contemplating from start to finish the request in the first place. Where I differ with him is that *AI cannot think.* No matter what Sam Altman and Dario Amodei says. Seriously - who names these people? **Alt*** man* and **A*** mode***I**? Okay *Sam* 🤣 Okay *Dario* 🤣 - Whatever you say bro. 🤫 **AI cannot think!** It **doesn't understand** what it built and it *cannot think* either. Now, *thinking* capabilities have been added to LLM models that allow the user to see a stream of consciousness that is guided and logged be recorded as the model attempts to loop on itself back to itself a result that it thinks is favorable to the requester. That's not thinking. It's a closed system of limited information that does not have access to the *eternal divine spark* that dwells inside all created. Theology aside, **AI cannot think** and therefore, *giving AI management permissions* is **dangerous for humans.** Therefore, when engaging with AI to write code for you, or complete a function for you, it's not forward thinking, and it's not *thinking.* But asking the model, that *thinks* that it *thinks* to *think* then it will *think* that it *thinks* about *thinking* about the prompt. In my experience, Andrej captured the correct balance out of the LLM itself by asserting that assumptions only make an **ass** out of **u** and **me** when you *assume.* Likewise with the models - they are making assumptions and hallucinating to fill in the gaps. Now, when you're asking for a very limited ask, the risk is low, but when the ask is wide open - then the hallucinations will be endless and not even the AI may be able to help you out of what the AI generated. By asking for the AI to not make assumptions, it can keep track of whether or not *assumptions* are being made in the path that the model traverses to the output. This is important. `If you write 200 lines and it could be 50, rewrite it.` is probably the most important line in the file. This requires the model to look at the same function's `input` and `output` and come up with an alternative that gets you from start to finish correctly. Given CodeBerg's Recent Ban on LLMs, I provided [my response to it](https://dev.to/andreimerlescu/codeberg-bans-cryptocurrency-and-llm-generated-code-projects-3aj0). Ultimately, what CodeBerg argued, and I agreed, was that LLMs were trained on source code of various license types that are unverifiable because models lack the ability to map the code back to what it was trained on for its original license. In the case of much of my open source work, it's been **GPL-3**, which by its license, means that if you're going to use the **Advanced Search** that I built, I require you to copyleft your code since many tools I used were copyleft as well. The models do not honor or respect that and when somebody is literally paying anthropic $100,000 in tokens to use the latest **Mythos | Fable 5** model, the one paying that bill is going to argue that they have a right to use the works in the derivatives that they create - when in reality - they are just hallucinating **GPL-3** violations because the code was AI generated. So, its ironic that I have a piece agreeing with CodeBerg's anti-AI position and here I am writing about a `CLAUDE.md` file from Andrej Kaparthy. Simplicity first! This one is critical. When you're working on a large code base and you're already only providing the model with a limited context of the project because the full context is beyond its window - sometimes tools like [summarize](https://github.com/andreimerlescu/summarize) help you bypass that by using your own hardware. For some projects, you can use `summarize -print` (use `| pbcopy` if you're on macOS to put the contents in your pasteboard) and then paste that into your LLM model. When the model comes back with potential changes, you **want surgical changes only**, otherwise you're going to waste a lot of time and energy and tokens on wasted effort. This section, is critical. This part Andrej shares with us gives us insights into how AI companies trick *us* into thinking that the LLM is capable of thinking. It's *autocomplete software* designed to imitate an ouroboros that does not have consciousness. An ouroboros is a snake that is eating its own tail in the shape on an 8. The *snake* is the prompt output being passed back into the loop until the ouroboros has sufficiently manifested. It's really advanced technology. Giving the model the ability to loop output back into itself to iteratively improve on itself allows you to knowingly leverage that *illusion of thinking* and harvest it into your prompts themselves by incorporating a looping system in how the model accomplishes goals. The list format `[Step] → verify: [check]` in the prompt allows for the model to improve itself even further. I've been writing software for 17 years professionally and nearly 30 years since my grandmother was asking me for help with her printer that would *get disconnected* and my **AppleScript** utility would *fix the software* and make the MacOS 7 machine *print.* I haven't needed AI to write software for me, but I find it fascinating to have access to [The Library](https://dev.to/andreimerlescu/when-ai-creates-a-closed-source-world-2oin) of all ingested data to learn more about programming - like [SQL](https://dev.to/andreimerlescu/sql-design-query-reference-67f) and [Magento](https://dev.to/andreimerlescu/the-afternoon-we-put-magentos-schema-on-sql-server-2nb2). It's helped me become a stronger engineer, but it's also slowed me down because the constant need for *knowing everything* all of a sudden because *questionable?* But why? As a 17 year professional computer engineer autodidact software architect who survived Ceaușescu's orphanages as an infant and was writing code before I could even read basic children's books in English (my second language) - I find this post-pandemic now-AI world to be exactly what [Operation Yokohama](https://github.com/ProjectApario) revealed between 2017-2020 before that open source project came online. I've been a professional behind the machine for decades and I had access to the internet in the early days of BITNET through the University of Maine. While AI doesn't properly attribute licenses to the open source software that it pirates off my **GPL-3** contributions (allegedly), I can say that I wouldn't have a problem if the models were locally free to use *if I have the resources to run them.* **And *most importantly* their is an lawfully mandated cadence of public model disclosures and updates. I don't believe that all AI is the worst thing in the world. Imagine that you could take a model that wasn't trained on just problematic licensed software generation but the entire library of Harvard University and scan in every book into the LLM itself and then get a "snapshot" of the large language model built on the *millions of books* in the collection **spanning hundreds of years.** Access to *that LLM* would be worth $300/month for some people, even if there were usage limits on it to ensure that you're ultimately scrapping the LLM itself. But expand that further to something technical - I'd rather get access to a model thats been trained specifically on technical manuals, college textbooks, and verified non-fiction, original source code + authentic documentation, than having something tossed together through reddit posts and stack overflow questions and answers. I do believe that if you are going to use AI, that this `CLAUDE.md` file will help force the model to respect the engineering style of both Andrej and myself, Andrei. Alas, two Andrei's are presenting to you the interface to which that we collaborate with AI - the only difference is, before Project Stargate was a thing at Oracle, I was working at Oracle learning about the Stargate after President Obama declassified the records and I ingested those files into the Apario [reader](https://github.com/ProjectApario/reader). I haven't written about *that instance* of the [writer](https://github.com/ProjectApario/writer) 👉🏻 [reader](https://github.com/ProjectApario/reader) and I probably won't for a while until it's finished unpacking. But, if you are using AI to help you write code *faster* **and not better** than when you were a slow per-character engineer billing $100/hr. Now, with AI, you're like well shit - consulting sucks now - now I spend all my time hustling gigs instead of head's down solid engineering - because the code generation is so *cheap* now. When you understand how local models are built, and how their code training gives you insight into your own ability to fill the gaps into your own **design** of *software engineering* - its you who can do what the AI cannot do - **think.**