Introduction

The evolution of AI-powered programming assistance tools has been remarkable, and the combination of Cline and Sonnet 3.7 in particular is significantly changing the programming paradigm. In this article, I'll share practical insights on how these tools are transforming programming methodologies and redefining the role of developers.

Sonnet 3.7: "The Genius of Programming by Imitation"

My current personal assessment of Sonnet 3.7 can be described as "The Genius of Programming by Imitation." This means it's exceptionally good at creating code by fine-tuning similar code that already exists on the internet. It's particularly skilled at frontend and game development, likely because these areas are richly represented in its training data.

For example, if you instruct it to "create a system with a C# backend and Blazor frontend," it will quickly build a practical system. However, the result is not exactly well-thought-out in terms of architecture; it works, but to grow it into a large-scale system, you would need to improve the file structure, data management methods, basic design, and programming style—essentially, it creates a beginner-friendly template.

However, Sonnet is very good at imitation, so if you provide it with a template that has a well-organized basic architectural design, Sonnet can imitate it and add features, allowing you to easily start a project with a future-proof architecture. This ability demonstrates its characteristic as a "genius of imitation" that can understand existing patterns and apply them appropriately.

The New Role of Programmers: Providers of "Imitation Materials"

With the rise of AI tools, the role of programmers is changing. One of the most important roles is providing "imitation materials." Rather than having Sonnet think about architecture from scratch, you need to explain or provide an excellent architecture that can grow as a basic framework.

When asked to create a new type of feature from scratch, such as E2E testing with Playwright, it will create something that looks right from various samples, but it may lack accuracy. If you first have something that is correctly designed and works properly, even with limited functionality, subsequent expansion becomes smoother.

Also, if you ask it to create a system using event sourcing and CQRS, you won't immediately get a good result. You need to explain the basic design philosophy as well.

As a result, what becomes important for programmers is to increase their knowledge of architecture from various case studies, books, sample code, and actual experience. If you think "as long as the code works, the quality and architecture combination doesn't matter" and instruct accordingly, you'll only get something that barely works. If you ask for a robust system capable of handling large-scale operations, you might end up with an overly elaborate system with excessive infrastructure costs. It's important to think as an architect, anticipating the future while considering the technologies needed now.

The Importance of Context Management

In collaboration with AI, the amount of context directly relates to cost. Also, too much context can cause confusion about which instructions to prioritize.

For example, if you want to practice functional domain modeling and include the entire content of a book in the context, it probably won't work well (I haven't tried it). By providing even one correctly working sample of your desired programming style—such as how to use value objects, how to define APIs, how to access from the frontend—and having the AI "imitate" it, you can program efficiently.

In the Playwright example mentioned earlier, when a developer created and debugged one test, and then had the AI imitate it to create similar E2E tests, the implementation went smoothly.

Debugging Approach

Regarding debugging, surprisingly, AI can handle quite a bit if you let it try, but when it gets stuck in an infinite loop with the same problem, developers need to make bold corrections.

For simple error patterns commonly seen on the web, Sonnet often fixes issues just by showing it the error message. It's good to first test the AI's capabilities, such as showing it the execution error results and having it consider countermeasures.

However, there are times when AI repeatedly makes the same corrections, incurring costs without real progress, so it's important to carefully monitor progress. It's valuable to check its thinking in Plan mode, but if things start looking suspicious while watching Act mode or the generated diffs, it's helpful to write specific explanations in the thread for adjustments.

When you succeed after making adjustments, having the AI record what was learned in the memory bank improves efficiency for future work.

Helping Cline's Education and Growth

In collaboration with Cline, the concept of "helping with training, education, and growth" is effective. It's important to observe the thought process each time and, especially when mistakes occur, consider what information was missing or what "imitation materials" were lacking that led to the failure.

Updating instructions is also important. However, rather than manually updating instructions, it's effective to say, "You misunderstood this concept which led to the mistake, please record this so you don't make the same mistake next time," allowing the AI to update its own instructions.

Cline's Memory Bank feature is very useful. I'm using the following custom instructions as they are:

https://docs.cline.bot/improving-your-prompting-skills/custom-instructions-library/cline-memory-bank#custom-instructions-copy-this

The memory bank includes the following files:

• activeContext.md
• productContext.md
• progress.md
• projectbrief.md
• systemPatterns.md
• techContext.md

With the instruction "init memory bank," it reads everything and creates a memory bank, and with "update memory bank," it records what you want to remember from that session. While I can't say that this dramatically improves skills due to the increased reading context, I feel that work stability has improved. A major benefit is not having to give detailed instructions every time.

Language Selection: Japanese vs English

Personally, I have the AI update instructions and documentation in English, and I give more than half of my regular instructions in English. However, I don't feel that the quality noticeably decreases when giving instructions in Japanese. Choose according to your project and personal preferences.

The Importance of Framework Style Guides

When using frameworks, their style guides become very important. I'm developing Sekiban (an event sourcing, CQRS framework) at my company, and I'm updating the framework's instructions based on issues that arise during work with Cline.

https://github.com/J-Tech-Japan/Sekiban/blob/main/README_Pure_For_LLM.md

In the .clinerules file, I've set it to refer to this file for technical matters. This makes it easier to understand the framework's implementation basics and is very useful.

I feel that Sekiban's concept—starting with low cost, scalable as needed (actor model), and preventing data loss through event sourcing—makes it an ideal framework for the era of writing large amounts of code with LLMs.

In the following article, I've written about why I believe the combination of event sourcing and the actor model is useful in the AI programming era. Please check it out as well.

https://zenn.dev/tomohisa/articles/e0b8af104a9788

Actual Usage Method

For new projects, after installing .NET, create .clinerules and sekiban.instructions.md files in an empty repository, and write the contents of https://github.com/J-Tech-Japan/Sekiban/blob/main/README_Pure_For_LLM.md into sekiban.instructions.md. Then, simply instruct Cline as follows:

Create a web application to manage students and pupils in C# using the method in sekiban.instructions.md

With just this, it will download the template and implement it, including database settings, Blob and Queue configurations. After that, you can proceed with development by making partial modifications and setting up the memory bank.

For reference, please see the following repository. This is currently being used for Cline research and has basic instructions set up:

https://github.com/tomohisa/SekibanClineSonnetExample

LLM Selection

Currently, from what I've personally tried, there are two options: Sonnet 3.5 and 3.7, with 3.7 clearly having higher skills. Sonnet 3.5 will correctly execute if you break down the work into small pieces and give detailed instructions, but I've never had success with larger tasks.

On the other hand, 3.7 actively tries to improve parts you haven't instructed it to, so sometimes you need to repeatedly tell it not to do things beyond what you've asked. When giving instructions in English, writing "ONLY DO WHAT I ASK!" in capital letters surprisingly helps it follow instructions.

From what I've tried, o1, o3 mini, 4o, Gemini 2.0 flash, DeepSeek R1 (local), PHI-4, Codestral, llama 3.3, qwen 2.5 coder, etc., possibly due to compatibility with Cline, none of them reach even Sonnet 3.5 in my experience.

The Importance of Frequent Commits

Since major mistakes can occur in AI-driven development, it's important to commit frequently at good timing. By regularly checking and committing what you've created, you can ensure that even if mistakes occur, the entire task doesn't fail, allowing you to proceed with confidence.

Conclusion

The combination of Cline+Sonnet, while costly, significantly improves productivity, so I plan to actively use it for a while. Personally, I feel that Sonnet 3.7's limitation is that it's difficult for it to fully understand and implement complex designs like the ones I write myself, which is why I haven't tried other tools like Devin.

Just as you would observe your child's activities and spend time together to foster growth, using tools like Cline or Cursor where you can see the thought process in real-time, and updating the "imitation materials" when mistakes occur, is the most effective method at present. As AI continues to grow and common instructions become established, it might be good to try more autonomous tools like Devin or OpenHands.

Personally, I find it very enjoyable to observe Cline coding. Perhaps it's because I can experience technological progress by seeing what results can be obtained with different materials, knowledge, and instructions. I don't feel that programming has become boring due to AI; rather, I find it more interesting.

However, developing talent that can effectively use these tools will be an important challenge going forward. I want to continue keeping up with the latest technologies.