Using AI in your daily development process requires a shift in how you think about writing code.
Having built websites for over 30 years, I’ve lived through many changes in how software is developed. AI is not the first major shift developers have had to adapt to, and it certainly won’t be the last. Like previous transitions, it has caused disruption, some of it useful, some of it driven by marketing hype that sets expectations far too high.
When those expectations aren’t met, the conclusion is often that AI has failed. In reality, it’s not that AI isn’t useful, it’s that it needs to be used differently. It works best as a tool within your workflow, not something you can simply turn on and forget.
Delving into Claude Code
My first attempt at using Claude Code didn’t go well. I approached it the way it was being marketed: asking it to “build a product.” The scope of that request was far too large. By giving the AI so much latitude, I was asking it to make architectural, stylistic, and framework-level decisions without sufficient context.
The result was a tangled web of code that often didn’t even respect the framework I had already set up. It would fall back to raw PDO statements instead of using framework tooling. It created methods and classes that were later abandoned but left behind. Coding standards shifted mid-stream, and the overall result felt incoherent.
This wasn’t a failure of Claude Code so much as a failure in how I was using it.
Second Attempt: Adapting the Approach
The second attempt required a mental shift. Rather than expecting AI to work instead of me, I needed it to work with me.
AI isn’t there to replace the developer, it’s there to support the developer. That means staying in control. In practical terms, this meant drastically reducing the scope of what I asked it to do and taking on more of an architectural role, guiding it much as I would guide a junior developer.
Instead of asking it to build an entire project, I broke the work down into much smaller pieces: a class, a method, or a clearly defined section of functionality. You can expand the scope somewhat, but keeping it small was critical while learning how AI fit into my workflow.
The results were noticeably better. There were still odd decisions, sometimes it used framework tools, sometimes it didn’t, but at this scale it was easy to catch and correct those issues. The code was generally solid, required some cleanup, and was far quicker to produce than writing everything myself. Importantly, the problems were easy to spot and fix.
The Importance of Review
Throughout this process, code review became even more important.
Any code you didn’t write yourself should be reviewed carefully, and AI-generated code is no exception. In truth, even code you did write yourself benefits from review, we all make mistakes.
Regularly reviewing AI-generated code helps keep things from becoming large and unwieldy. It’s how you maintain control, catch deviations early, and ensure the codebase stays consistent and understandable.
Attempt Three: Teaching AI How I Code
While the output from the second attempt was good, it still didn’t feel quite right. The code wasn’t bad, it just wasn’t how I would write it.
In PHP, there are countless ways to solve the same problem, but most developers have their way of doing things. If Claude Code could follow my preferences, there were clear benefits: the code would feel familiar, differences would stand out more clearly, and issues would be easier to identify.
The third attempt focused on creating a claude.md file that clearly documented how I wanted code to be written. This included decisions around function and variable naming, whether to use static methods, specific usage patterns for Flight PHP (my framework of choice), the PHP version I target, database choices, dependency injection approaches, and adherence to SOLID principles.
That file grew to around 500 lines of guidance, including examples of what to do, and what not to do. With those constraints in place, working with Claude Code became a much more pleasant experience.
Having detailed instructions on how to code also made it possible to slightly increase the scope of requests, though still not to the level of “build me an entire product.”
Final Thoughts
Whether you love AI or hate it, learning how to use it has become important for long-term relevance as a developer. Not taking the time to understand how it can best support your workflow risks being left behind.
One unexpected benefit I’ve found is that development feels more restful. Building software is mentally demanding, from designing architecture to writing code to reasoning about database access. Allowing AI to take on some of that load can reduce cognitive strain without sacrificing quality.
You still can’t let it run unchecked. You’re ultimately responsible for the code it produces. But by guiding it with clear constraints and documentation, and by keeping yourself firmly in control, AI can become a focused, effective, and genuinely helpful part of your development process.
It's not magic. But used well, it might just make the work a little lighter.
Top comments (0)