Executive Overview
In Part 1, we covered the “thinking layer”— how AI improves architectural reasoning. Now we shift to the execution layer: how AI improves daily coding, testing, refactoring, debugging, and delivery.
Over the last few months of production work, this workflow consistently delivered:
- ✔️ ~70% time savings on code scaffolding
- ✔️ ~78% faster test generation
- ✔️ ~67% faster debugging cycles
- ✔️ More consistent Laravel architecture
This is the practical playbook behind those numbers.
1. AI-Accelerated Code Scaffolding
AI excels at generating structured, consistent scaffolds—if you provide a strong, detailed and precise specification.
Service Classes (83% Faster)
- Traditional: 60–75 minutes
- AI-assisted: 10–15 minutes
My Prompt Strategy:
I use Windsurf combined with Laravel Boost (to enforce modern Laravel patterns) and provide a prompt like this:
"Create a
SeasonalDiscountServicethat retrieves active discount rules from config/discounts.php.Requirements:
- Methods:
getDiscountForCategory(string $category),getActiveCampaigns(),calculateImpact().- Use dependency injection and full type hints.
- Handle expired campaigns gracefully with defaults.
- Constraint: Return a strictly typed
DiscountDTO, never a raw array."
The Result: A production-ready service class with proper namespaces, docblocks, and error handling. I step in only to validate the business logic.
2. AI-Enhanced Refactoring
Refactoring legacy code is safer with AI — but requires synchronization.
The “Explain → Verify → Execute” Loop
When dealing with complex, "spaghetti" legacy logic, I never jump straight to refactoring. I use a synchronization step first:
- Explain: I highlight the complex method in Windsurf or sometimes the whole flow of execution of the feature, and ask: > "Explain the logic of the method or feature flow step-by-step."
- Verify & Correct: I review the AI's explanation. If it misinterprets a variable or edge case, or omits some part of the logic, I correct it explicitly in the chat.
- Execute: Only once I have confirmed the AI's mental model matches the existing implementation, do I issue the refactor command, while adding constraints where necessary.
The "Reverse Code Review"
Sometimes I flip the script. I will manually refactor the AI's code (or existing legacy code) to apply a specific design pattern or personal preference, and then I ask the AI to review my work.
Prompt:
"I have refactored your logic to use thematchexpression instead of theswitchstatement. Review my changes for regressions, missed edge cases, or logic errors. Then, merge the best parts of my refactor with your original error handling."
The Result: The AI acts as a safety net. It often catches subtle bugs I introduced (like missing a null check during my refactor) and upgrades the final code by combining my architectural structure with its robust boilerplate.
The "Hardcoded to Config" Move
Prompt:
"Extract all hardcoded rate limits, API timeouts, and retry thresholds in this controller intoconfig/discounts.php. Make them environment-variable configurable."
Real stats: I recently moved 20+ hardcoded values in 20 minutes. A task that usually takes around 1 hour of tedious copy-pasting, which is also prone to errors of omission sometimes.
3. Testing: A Force Multiplier
Testing is usually the first thing to slip when deadlines loom. AI reverses that trend when utilised properly.
- Traditional: 120 minutes
- AI-assisted: 25 minutes
- Time saved: ~79%
Generating the Suite
I don't write tests from scratch anymore. I ask AI to generate the skeleton and the standard cases:
"Create unit tests for
LoyaltyPointsCalculatorcovering:
- Gold Tier: Earns 2x points on all orders.
- Silver Tier: Earns 1.5x points only on weekends (mock the date).
- Standard Tier: Earns 1x points.
- Edge Case: Orders over $1,000 get a flat 500-point bonus regardless of tier."
The "Blind Spot" Check
"What edge cases am I missing for this points calculation?"
AI Result: "You missed: Refunded orders (negative points), zero-dollar orders, and floating point precision errors on multiplier math."
Running Tests With AI
I also use AI to run my test suite.
- It picks up failed test cases automatically.
- It proceeds to investigate the cause of the failures and recommends multiple solutions.
- After my review and decision, it implements the fixes and reruns the suite.
- It automatically runs the test suite after significant refactoring to ensure no regressions.
- It can also suggest additional test cases for improved test coverage for the codebase.
4. Documentation: The Silent Productivity Killer
Documentation is the task every engineer hates, but every team needs. AI turns this from a chore into a breeze.
AI allows me to effectively document code and applications, making handovers and onboarding new devs effortless compared to manual effort.
My Documentation Workflow:
- Code Comments: "Add strict DocBlocks to this service class explaining the business rules for the discount calculation."
-
Onboarding: "Read this repository and generate a
CONTRIBUTING.mdfile that explains how to set up the environment, run migrations, and seed the database." - API Docs: "Generate Swagger/OpenAPI definitions for these 3 new endpoints."
Result: I consolidated 31 fragmented documentation files into 1 comprehensive README in 30 minutes, saving ~2 hours of manual work.
5. Infrastructure & Deployment: The DevOps Accelerator
I am a Backend Engineer, not a full-time DevOps specialist. AI helps bridge that gap by generating, explaining, and debugging deployment scripts and also build errors that I would otherwise spend hours Googling.
Writing & Learning
Instead of copying opaque Bash scripts from StackOverflow, I now use AI to build and teach me the infrastructure.
The Prompt:
"Write a GitHub Actions workflow to deploy this Laravel app to a DigitalOcean Droplet via SSH.
Requirements:
- Run tests before deploying.
- Use
rsyncfor zero-downtime file transfer.- Reload PHP-FPM after transfer.
- Explain: Add comments explaining what every flag in the
rsynccommand actually does."
The Result:
- A working CI/CD pipeline.
- A clear explanation of why we use
rsync -avz(archive mode, verbose, compressed). - I learn while I build, rather than just copy-pasting.
I apply this same logic to Dockerfiles (optimising layers), Nginx configs, and Makefiles.
6. Debugging: Ranked Root Cause Analysis
Stop staring at stack traces. Use AI to structure your diagnostic thinking.
My Debugging Workflow (15-20 mins):
- Input: Error message + Code Context + Recent Changes.
- Prompt: > "Based on this error, provide 3 likely root causes ranked by probability. For each, suggest a verification step."
- Action: I test the "70% likely" cause first.
7. The Data: Real World Time Savings
Let's look at the actual numbers from 12 months of production work.
| Task Type | Traditional Time | With AI | Time Saved |
|---|---|---|---|
| Service Class | 60 min | 10 min | 83% |
| Test Suite | 120 min | 25 min | 79% |
| Documentation | 120 min | 30 min | 75% |
| Debugging | 60 min | 20 min | 67% |
| Refactoring | 90 min | 30 min | 67% |
The Takeaway: This results in a 25-30% net productivity gain per engineer. For a team of 5, that’s the equivalent of adding a 6th engineer without the headcount.
8. My Multi-AI Prompt Strategy
The secret to high-quality output is a two-step process:
- The "Thinking" Step (ChatGPT/Gemini): I dump my messy requirements here. "I need to implement a new rewards tier..." I ask the AI to structure this into a technical spec.
- The "Execution" Step (Windsurf + Laravel Boost): I feed the refined, structured spec into Windsurf. It executes with full codebase awareness and Laravel-specific context.
The Rule: Invest 5 minutes in prompt design to save 30 minutes of cleanup.
The "No Assumptions" Clause
I always explicitly instruct Windsurf:
"Do not make assumptions. If any part of this requirement is ambiguous or open to interpretation, ask clarifying questions before you generate any code."
This simple instruction prevents the AI from confidently guessing wrong and forces a clarification loop that saves hours of rewriting later.
The Seniority Gap: Asking for Features vs. Asking for Architecture
One of the clearest indicators of seniority isn't just the code you write—it's the prompt you write.
The "Junior" Prompt:
"Build a registration form with first name, last name, email, phone number, and address."
- The Result: Happy-path code. It works, but it’s fragile. It likely misses validation and lacks atomicity.
The "Senior" Prompt:
"Create a user registration endpoint.
Technical Constraints:
- Validation: Enforce strict typing. DNS/RFC validation on production.
- Data Integrity: Wrap the user creation and profile setup in a database transaction to ensure efficient rollback.
- Performance: Email uniqueness check via optimized indexed query.
- Security: Sanitise inputs to prevent XSS and mass-assignment."
- The Result: Enterprise-grade code that is secure, atomic, and environment-aware.
9. Guardrails: Where I Draw the Line
AI speeds up execution, but I own the quality. Here is my safety checklist:
- Security: I never blindly trust AI with auth logic or input validation.
- N+1 Queries: AI loves to write inefficient loops. I always review database interactions.
- Business Logic: AI can write the code, but only I know if the Loyalty logic matches the Marketing team's request.
- Secrets: Never paste API keys or real customer data into the prompt.
Closing Thoughts: The Future of Hybrid Engineering
Teams that master structured AI workflows will ship faster, maintain higher quality, and onboard engineers quickly. Hybrid AI-assisted engineering isn’t the future—it’s the present.
Meta Note: In true "practice what you preach" fashion, this article’s structure was refined using the same AI-assisted workflow described above: structured prompts, multi-AI refinement, and final human review.
(Now, if only I could prompt the AI to explain to my PM why this "5-minute fix" will actually take three days... ☕)
Which part of your engineering workflow would you delegate to AI first — and what’s stopping you from doing it today?
About the Author
Senior Backend Engineer specialising in Laravel, distributed systems, and backend architecture. Focused on scalable systems and hybrid AI-assisted engineering workflows.
Read Part 1: Decision-Making, Architecture, and Problem Solving
Top comments (0)