I'm going to share my beginner journey of coding with AI and how it changed over time. I've gone through several what feels like distinct phases. Those phases are marked by better results and quicker implementation. Each one dramatically changed how effective I was as a developer.
1: The Copy-Paste Phase
I started with the most basic version of using AI for coding, which was getting the AI to understand what I was talking about, and then copy-pasting the results.
This phase was treating AI like another search engine - similar to how I used Google or Stack Overflow. I'd get an answer from ChatGPT and copy it back into my code. Pretty basic, but it was a start.
- Change: Talk to LLM.
- Results: My coding was the same workflow, using a different resource for solutions.
1.5: The Structured Prompts Phase
The next phase came from studying OpenAI's prompting guide. This is where I learned how to use AI more effectively to get better results. I learned to have the AI think deeply, to break up tasks into simpler tasks, and to structure what I wanted the results to be like.
So adding OpenAI's prompt engineering docs into my workflow helped a lot. I was able to fit a lot of information in simpler prompts with better results.
This approach dramatically improved my results, and I started using ChatGPT much more. While I wasn't using system prompts, I was making better prompts which made a difference.
- Change: Prompt engineering.
- Results: Same workflow. Clearer prompts. Better results (less bugs, less back-and-forth). More ChatGPT usage.
2: The Cursor and Style Docs Phase
The next big shift came when I started using Cursor. This tool changed my workflow because it could see my code context directly - less copying and pasting.
However, I noticed some consistency issues when switching between different AI models. ChatGPT and Claude would sometimes solve the same problem differently, or get confused about previous decisions made outside their chat context.
This led me to start using style docs in Cursor. Game changer. By providing style docs, I maintained consistency between different models. These docs included specifications like:
- Technology choices (e.g., "using JavaScript")
- Architecture decisions (e.g., "use functions, not classes")
- Code examples
- Linting preferences
This was my first big "ooh god" moment about AI's power in development. It gave me the idea that AI could do it with me and in many cases do it better, faster, and for me. I was using Cursor Chat so I was still copy-pasting but I was using the AI to create it.
- Change: Cursor Chat. Style docs.
- Results: Same workflow. Consistent results. Better results (less bugs, less back-and-forth). Much more Claude usage. Quicker implementation.
3: The Docs and Structure Phase
After reading an article about AI pair programming, I gained a deeper understanding of using docs and structure to guide the AI. This helped me:
- Keep the AI from going off the rails
- Kept us grounded in the plan
- Maintain consistency across different models
- Reduce back-and-forth corrections
With implementation, design, and style docs in place, I could create more direct and shorter prompts. The structure moved from the prompts themselves into the documentation. So I guess it was in the prompt, just in a different way, right?
- Change: Design docs. Implementation docs. Adding tool documentation. Less structured prompts.
- Results: More upfront planning and documentation gathering. Consistent results. Stayed on task much more. Much more Claude usage.
4: The Documentation and Saving Phase
The final major phase in my early AI coding journey was developing a documentation and saving strategy. At the end of each session, I started saving summaries of what we accomplished - similar to git commits but for AI interactions.
This practice of saying "Please save our chat session" or "Please summarize this in a markdown file" became crucial. I learned that LLMs work better with structured documentation they can reference. Creating these "save points" made it easier to:
- Track decisions, thought processes, and progress
- Maintain context between sessions
- Help the AI understand our historical context
- Create clear breakpoints in development
Once I established this workflow, my use of AI in coding expanded dramatically. Maintaining context between sessions was a very big thing. I jumped back into the progress of the project by asking the AI to refer to the implementation plan. That included asking it to update the implementation plan with the new changes after our sessions. I got this tip from the Latent Space community.
- Change: Session docs. Updating implementation plan and documentation. Using best practices from Latent Space.
- Results: Session summaries. Less recaps and more progress. Common problems disappeared.
I'm sharing these thoughts to help others who are starting their AI coding journey. Plus, I want to remember how I started now that my workflow is different. There's more to cover about advanced techniques and workflows, but these early phases and their incremental improvements were helpful to my growth.
Beyond this Workflow
Here are a few things I am exploring to change my workflow:
- Adding more Deep Research in the mix.
- Adding v0.dev to create faster and more responsive UIs.
- Multimodal inputs and outputs. Using my voice just speaks to me.
- Guardrails on Cursor Composer. Do it yourself to Do it for me.
- MCP & Agentic workflows. Such as using Claude Desktop, Descript, and Canva to create YouTube videos automatically.
- Using Claude to control other parts of my workflow such as creating the social media posts for this blog.
- More Context: web scraping, adding repos with repomix, etc.
- Create systems that use LLMs to write software