Working Notes
A collection of technical observations, code snippets, and experimental results from building software with AI.
What are the notes about?
These notes record what actually happens when AI‑generated code runs in a production‑like environment. They capture friction points, the adjustments needed, and the concrete outcomes of each experiment, avoiding abstract theory. The focus is on reproducible observations that other developers can verify on their own machines, providing a practical reference instead of speculative advice.
Each entry is structured around a problem, the attempted solution, and the resulting behavior. By documenting the precise failure of a prompt or a logic flow, the notes become a troubleshooting guide. Developers can search for similar patterns and apply the recorded fixes, turning isolated incidents into reusable knowledge.
How are methods and measurements captured?
Success is measured by the accuracy of generated logic and the ratio of debugging time to prompting time. Traditional metrics such as lines of code are ignored because they do not reflect the effort required to make AI output usable. The notes log these ratios for each small module, revealing which prompting strategies yield sustainable workflows.
The methodology relies on iterative testing of atomic functions rather than requesting full applications. Breaking tasks into tiny units reduces error rates and keeps the debugging effort manageable. Results from each micro‑test are recorded verbatim, creating a data set that can be consulted when designing similar prompts or refactoring code.
Where can I find the code snippets?
The snippets included are the exact fragments that solved the recorded problems, not generic templates. Each piece is accompanied by the surrounding error context, showing why the fragment was necessary and how it resolved the issue. This level of detail paints a clearer picture of the debugging journey than a polished final version would.
When reusing a snippet, attention must be paid to the surrounding architecture. AI‑generated blocks often lack awareness of system state, so the notes demonstrate how to wrap them in error handling and type safety. Applying these wrappers ensures the code behaves predictably within larger, complex software ecosystems.
How is the archive organized?
Entries are grouped by technical topic rather than by date, making it easier to locate a specific hurdle. Topics span prompt engineering for logic, state management in modern frameworks, and other practical concerns that arise during AI‑assisted development. This topical arrangement supports quick lookup when a developer encounters a familiar problem.
New notes are added as experiments finish, keeping the archive current with recent experience. To start using the collection, look at the latest entries in the coding section, where specific logic errors and their iterative resolutions are described. The structure encourages developers to follow the same experimental cadence.
What pattern do the notes follow?
Each note follows a consistent pattern: describe the problem, outline the attempted prompt or code change, and record the result. This avoids generic advice and forces the author to capture concrete failures and successes. The pattern turns vague observations into actionable data that can be filtered and compared across projects.
By adhering to this format, the notes become a practical tool for developers who need to solve similar issues in their own environments. The explicit recording of what did not work is as valuable as the final solution, because it prevents repeated trial‑and‑error on the same edge cases.
How to use the notes in my project?
Begin by identifying the topic that matches the challenge you face, then read the relevant entry to understand the exact prompt or code tweak that succeeded. Replicate the snippet in a sandbox, adjust surrounding calls to fit your architecture, and run the same tests described in the note. This mirrors the original debugging path and reduces unknown variables.
After confirming the fix works locally, integrate the adapted code into the larger codebase, applying the error‑handling wrappers shown in the note. Monitor the same metrics—debugging time versus prompting time—to ensure the improvement scales. The notes serve as a living checklist for each step, from prompt to production deployment.
Questions
Are these notes tutorials?
No. They are technical logs of experiments and observations intended for experienced developers.
Can the code be copied directly?
The code is provided for context. It should be adapted to your specific project requirements and tested thoroughly.