Improving LLM Code Generation with Prompt Engineering

Yesterday I shared some notes on working with LLM-assisted coding, and how I achieved around 70% code completion but struggled with context retention and hallucinations. Today, I'm sharing an improved approach that pushed this closer to 80% completion while working on a frontend API integration feature. The key was breaking down the process into smaller, more focused phases.

The Three-Phase Approach

1. Context Loading Phase

Instead of dumping all requirements at once, I started with a dedicated context-building phase. I provided Cline (Anthropic's coding assistant) with the problem statement and relevant file references, then had it generate a comprehensive context prompt. This prompt included detailed summaries of existing functions and their interactions, creating a solid foundation for the next phases.

2. Analysis Phase

Using the generated context, I prompted Cline to create a detailed implementation plan. The key difference here was asking for specific code snippets that would need changes and identifying all affected files. This pre-implementation analysis helped avoid the hallucinations I encountered in previous attempts, where the LLM would invent non-existent components or interfaces.

3. Incremental Implementation

Rather than attempting to generate all code at once, I broke down the implementation plan into smaller steps. Each step was individually prompted, implemented, and validated before moving to the next. This approach significantly reduced context loss and kept the generated code aligned with our existing codebase patterns.

Results and Insights

While I could have implemented this feature faster manually, the exercise proved valuable as a learning experience. The generated code was notably more accurate and required less rework than my previous attempts. More importantly, it helped establish a repeatable process for LLM-assisted development.

Practical Tips for LLM Code Generation

For developers looking to try this approach, here are some crucial tips:

1. Commit Frequently: Create a feature branch and commit after each successful generation step. This provides safety nets when the LLM takes an unexpected direction.
2. Leverage Your Tools: Keep linting and testing running in watch mode. These tools provide immediate feedback on the generated code's quality and help catch issues early.
3. Stay Focused: Keep your prompts focused on specific tasks rather than trying to solve everything at once. This helps maintain context and reduces hallucinations.

Conclusion

While LLM-assisted coding might not always be the fastest approach today, developing effective prompting strategies is becoming a crucial skill for developers. This three-phase approach demonstrates that with proper structure and tooling, we can achieve more reliable and accurate code generation.

The key isn't just using these tools, but learning how to effectively communicate with them to achieve consistent results. As these technologies continue to evolve, the investment in learning these skills will become increasingly valuable.