تدفق عمل توليد التعليمات البرمجية للنماذج اللغوية الكبيرة لهاربر ريد: من العصف الذهني إلى التنفيذ

Harper Reed details his current workflow for using Large Language Models (LLMs) to generate code, emphasizing a structured approach designed to minimize wasted time and maximize productivity. The workflow is broken down into distinct phases, including idea honing, detailed planning, and iterative execution. Reed shares insights gleaned from his own experience, conversations with fellow developers, and industry best practices. This post provides a practical guide for developers looking to integrate LLMs into their coding process, whether starting a new project or working with an existing codebase.

Greenfield Development: A Three-Step Process

Reed outlines a three-step process ideal for greenfield development, focusing on meticulous planning and documentation to facilitate smooth execution in small, manageable increments.

• Idea Honing: Use a conversational LLM (e.g., ChatGPT) to refine the project idea through iterative questioning, ultimately generating a comprehensive specification document (spec.md). This spec can then be used for various purposes, such as identifying weaknesses in the idea, generating a white paper, or developing a business model.
• Planning: Leverage a reasoning model (e.g., o1, o3, r1) to create a detailed, step-by-step blueprint for building the project. Break the plan into small, iterative chunks, ensuring each step is small enough for safe implementation with robust testing. The output should be a prompt_plan.md containing a series of prompts for a code-generation LLM. A todo.md checklist is also generated to track progress.
• Execution: Execute the plan using a code-generation tool like Aider, Cursor, or Claude. Reed prefers pairing raw Claude with Aider. Claude is used for iteratively executing prompts and debugging code through Repomix. Aider automates the code generation process, including running tests and debugging.

Legacy Modern Code: Incremental Iteration

For working with existing codebases, Reed advocates a more task-oriented approach, focusing on incremental improvements rather than comprehensive planning.

• Context Gathering: Use a tool (Reed uses Repomix) to extract relevant source code and package it into an output.txt file for the LLM. Mise tasks are utilized for various transformations, such as generating code reviews, GitHub issues, missing tests, or READMEs. The flexibility of Mise allows for overriding configurations based on specific codebase requirements.
• LLM Interaction: Pass the output.txt to the LLM to perform transformations, saving the results as markdown files. For example, generating missing tests involves running a Mise task to create a missing-tests.md file, then using the contents of this file along with the codebase context to guide the LLM.
• Execution (Claude/Aider): Integrate the generated code using either Claude or Aider. With Claude, manually copy and paste the code into the IDE, run tests, and repeat. With Aider, paste the prompt, watch Aider automatically generate and test the code, and address any issues.

Prompt Magic: Enhancing Codebases

Reed shares several prompts he uses to enhance established codebases, including prompts for code review, GitHub issue generation, and identifying missing tests. While he acknowledges these prompts are somewhat outdated, they offer a starting point for improving code quality and robustness.

• Code Review: A prompt to conduct a thorough code review and output the review in markdown format, including line numbers and contextual information.
• GitHub Issue Generation: A prompt to identify bugs, design choices, or code cleanliness issues and format them as GitHub issues.
• Missing Tests: A prompt to identify missing test cases and write code tests.

The Solo Hacker Experience and the Need for Multiplayer LLM Coding

Reed laments the predominantly single-player nature of current LLM-assisted coding workflows, noting that coding is generally better with people. He calls for solutions that facilitate team-based coding with LLMs, addressing challenges such as bot collisions, merge conflicts, and context complications. He believes that this is a critical area for innovation.

Mitigating Downtime and Addressing Skepticism

Reed acknowledges the downtime associated with waiting for LLMs to process code, suggesting activities like brainstorming new projects, listening to music, or engaging in simple games to fill the time. He also addresses the skepticism surrounding LLMs, highlighting concerns about power consumption and environmental impact. He recommends Ethan Mollick’s book “Co-Intelligence: Living and Working with AI” as a balanced perspective on the benefits and challenges of AI.

In conclusion, Harper Reed’s workflow offers a valuable framework for leveraging LLMs in software development, emphasizing structured planning, iterative execution, and continuous improvement. Despite the challenges and potential pitfalls, Reed advocates for exploring the possibilities of LLM-assisted coding, encouraging developers to experiment, adapt, and ultimately enhance their productivity and creativity.

Source: Harper Reed’s Blog