Experiences from building systems leveraging AI models. I encourage developers to explore AI tools and collaborate with each other to aid in improving productivity and learning. Effective AI integration requires understanding the technology, structuring tasks, and maintaining disciplined oversight for sustainable productivity gains.
Introduction
Fall of 2024, I cautiously dipped my toes into the waters of Large Language Models (LLMs) in my day-to-day code development. Little did I know, I was embarking on a transformative journey. Over the past year, I have been working primarily with AI-integrated development environments (IDEs) like Cursor. I’ve seen a significant evolution in my workflow, productivity, and understanding of how AI can assist developers. From a modest 10% productivity boost, I’m now leveraging AI to significantly increase my output. This post chronicles that year, the tools I used, the challenges I faced, the successes I celebrated, and the crucial lessons I learned along the way.
The First Steps
November - December 2024
My initial foray began in November 2024, starting with Anthropic’s Claude LLM. I used basic prompts to help write tests, implement small features, troubleshoot bugs, and review code changes. The novelty was high, but the execution was simple: prompt the AI, copy-paste the suggested code into my editor, and make necessary corrections. My AI prompts gradually became more directed with code snippets to trouble shoot failed tests.
The biggest early lesson? AI isn’t a replacement, but a tool that needs supervision. The code generated was often a starting point, requiring careful review and refinement by me. Trust was low initially.
Building Trust and Efficiency
January - March 2025
2025 started with experimenting with Agents in Cursor. Copy and paste were becoming less prevalent. Cursor now allowed full files as context. Providing context and specifying files yielded better results. Trying YOLO (You Only Look Once) mode on small tasks was intriguing, but I remained cautious. I found the greatest potential lay in using the Agent when I needed to repeat specific tasks, recognizing this as a prime candidate for a rule.
This realization led me to build rules within Cursor. Defining guardrails for the Agent was crucial to increasing my trust in the LLM. Rules helped standardize code generation, enforce best practices, and build trust. I discovered a sweet spot: identifying recurring patterns (like correcting failing tests) and turning them into rules, automating the correction process and freeing me from repetitive cycles.
Anthropic’s Claude model remained my go-to, evolving from simple prompts to more structured interactions guided by rules.
Refining the Process and Exploring New Tools
April - August 2025
I continued on with more rule refinement and exploration of features like parallel conversations in tabs, making my workflow smoother. I started using the Agent more for targeted tasks like bug fixes, leveraging its ability to work on specific files. Collaborating with teammates helped to share rules and experiences.
I continued to tweak the AI’s behavior, adding prompts to encourage objectivity and incorporating notification sounds for completion. The concept of “vibe coding” – letting the LLM model work in the background while I focus – started to take hold.
Along this journey, I learned of tools that provided more structured thinking for the AI. These tools introduced were BMAD and subsequently, Code Captain. Tools designed for structured AI collaboration became the testing ground for the team. It provided the ability to analyze codebases, propose architectures, and generate detailed specifications for features. We found this to be quite powerful. It felt less like an LLM writing code and more like a collaborative partner, forcing a clearer upfront design and contract before code generation. This feedback loop was invaluable for understanding the LLM’s proposed changes and refining them to meet expectations.
As the months progressed, I increased my use of AI partners that enforce design contracts before code generation for larger features, leveraging the feedback loop for natural collaboration during specification development. I refined my rules based on recurring errors in code generation, gradually increasing the LLM’s autonomy while maintaining control through review. Reviewing and testing generated code rigorously became standard practice.
September brought the / slash command for executing terminal commands
directly in IDEs, like Cursor, and Plan Mode.
While Plan Mode was useful, the feedback loop of Code Captain felt more natural for complex feature development.
The ability to run terminal commands (sandbox) proved helpful for continuous testing during development (“vibe coding”).
Maturity and Integration
September - December 2025
My use of the new tools became solidified. Cursor released the sandbox feature, enhancing the collaborative “vibe coding” experience. In November, Cursor brought improved Plan Mode with clarifying questions, helping refine the working contract. In December Cursor released the ability for Plan Mode to generate Mermaid diagrams – visual aids that significantly enhanced feature understanding and communication. I started leveraging this ability to help enhance the documentation for the application under development.
The Year in Review: Productivity and Growth
Reflecting on this year, the transformation is clear. My initial gains from simple AI interactions were just the beginning. The real leverage came from strategically using tools like Agents, Rules, Plan Mode, and systems for structured AI collaboration, like Code Captain. This meant moving beyond simple prompts to a more defined, governed process where AI was integrated systematically to enhance productivity. The key wasn’t just using AI, but using it effectively and structurally.
Key Lessons Learned:
- Start Simple, Build Guardrails: Begin with clear, supervised tasks. The most significant productivity gains come from identifying repetitive patterns and codifying them into rules or processes (like detailed specifications).
- Treat AI Output as a Proposal: Treat AI output as a first draft or proposal, not necessarily the final implementation. Always review, supervise, and question the process. It’s crucial to understand the why behind the code.
- The Power of the “Working Contract”: Whether it’s rules, detailed specifications, design diagrams, or Mermaid diagrams, having a clear, agreed-upon contract before or during code generation drastically improves outcomes and reduces surprises.
- Iterate and Refine: Your relationship with AI tools evolves. Continuously review AI-generated code, provide feedback, and refine your prompts, rules, and processes. Be willing to experiment with new tools and features.
- Monitor Evolution: The landscape changes rapidly. Actively monitor updates and changelogs for your AI tools and environments to leverage new AI integrations effectively.
- Balance Autonomy and Oversight: Gradually increase the AI’s autonomy as trust grows, but never lose the crucial step of reviewing and verifying the results. Challenge both yourself and the AI to find the best solution.
Conclusion
My first year using AI in code development has been exhilarating and highly productive. Moving from simple prompts to sophisticated collaborations with tools like Code has fundamentally changed my approach to development. Working with large language models isn’t just about using a specific tool; it’s about understanding their capabilities and limitations, structuring tasks effectively, and maintaining a clear development process. AI is indeed a powerful tool, demanding the same skills of critical thinking, discipline, and continuous learning we apply to other technologies. The landscape evolves rapidly, but the core challenge remains: how do we integrate these powerful systems effectively and safely?"
The journey is ongoing, and I’m excited to see where the next years take us as AI and development tools continue to evolve together.