Don't let craftsmanship die!
Keeping craftsmanship alive when LLMs write code. Using AI assistants without sacrificing design, safety, and readability.
I am a fullstack engineer and spend most of my time building stuff with NodeJs & PHP. My daily work involves, brainstorming, discovery, running peer reviews, writing feature code, unit tests, etc and helping the team where needed.
Claude Code just mass-produced 400 lines across three files in under a minute. The merge request looks clean, the tests pass, the diff is tidy. So why did it take three days to get through code review?
Agentic coding tools have genuinely changed how fast we ship. But speed has a way of quietly lowering the bar if you're not paying attention. Before you hit "Create Merge Request" next time, ask yourself:
Are you ensuring quality ?
When you raise a merge request using Claude Code or any other agent on a critical project:
Did you think about readability, maintainability and simplicity of the changes ?
Have you carefully thought about handling failures ?
Did you think about reducing branching complexity ?
Have you made sure the LLM didn't re-implement something that was already part of the codebase or utility functions ?
Are the changes elastic and easily extensible ?
If you let it slip
If you let the LLM steer your code without carefully reviewing it, the following things happen:
You get bugs lurking around revealing themselves in a situation you didn't think of.
Your code is stuck in code review for longer as the reviewer has to spend more time ensuring quality.
Over time, the codebase becomes harder to maintain.
Harder onboarding: I have personally felt this multiple times, throwaway projects that are vibe coded are harder to understand because of accidental complexity.
Use it the right way
Add rules, skills, prompts, agents, etc to help the cli agents write code that's consistent with the quality of the repo.
Add stronger linting, formatting and static analysis tools to the project. Keep things strongly typed!
Make design decisions yourself, write it in a plan file, pass it to the LLM. Critique the LLM's plan, ensure it's making the right decisions, spend more time here and then leave it to cook.
Carefully review the written code, think about simplifying and untangling the changes, use multiple LLMs to review the code before raising it as a merge request.
Make tests compulsory!, if code can be written faster, tests can be too. Ensure every change is accompanied by tests.
Raise the bar!
Make use of LLMs to ensure that higher quality of code is shipped in lesser time.
Move fast ensuring quality.
Spend time on optimizing things that you didn't get time to optimize previously.
Evolve with the tooling, LLMs are getting better at this and we need to evolve our workflows too.
Use the time you save to get better at designing systems and develop systems thinking.
Think like a PM! when you can build things faster, what matters if you truly understand the problems, and can differentiate between what's not worth building vs things that will actually be valuable. Outcomes matter more than output, the quantity of problems solved doesn't matter if it doesn't bring business outcomes.
