Web development timelines that once stretched across months are now being compressed into weeks, sometimes even days. As artificial intelligence tools become more sophisticated and accessible, developers are discovering they can automate repetitive tasks, generate boilerplate code, and even debug complex issues faster than ever before. But beyond the hype and bold claims, what does the actual data tell us about AI's impact on development speed?
In this article, we'll dive into real metrics from our developer who have integrated AI into their workflows and explore which aspects of web development see the biggest improvements.
Without furtherdue, let’s start with the first case.
Case #1: PWA for Symfony - for Frontend developer
A frontend developer faced what seemed like a straightforward task: integrating a Progressive Web Application into an existing Symfony project. The initial PWA setup was straightforward - basic tutorials and hardcoded configurations established the foundation across local, test, and production environments.
However, the work got complicated when the client introduced asset versioning. The client's build process generated unique filenames for compiled JavaScript, CSS, and image files with each deployment. This broke the PWA's core functionality, as the service worker and manifest files still referenced the old, non-versioned filenames.
Why was this particularly challenging?
It occurred that this wasn't a typical frontend task. Several factors made it complex:
- PWAs remain a niche specialization with limited community resources
- Asset versioning with PWAs creates unique integration challenges rarely covered in tutorials
- Project setup tasks like this happen infrequently (maybe twice per year), so even experienced developers aren't always fluent
- No one else on either development team had relevant PWA experience
The developer had built PWAs before, but never with dynamic asset versioning - a crucial difference that invalidated most existing knowledge and resources.
The AI-assisted solution
Using Claude AI, the developer started with focused questions about configuring the service worker to handle versioned assets:
I have a symfony project with encore installed. I'm using asset versioning via encore's enableVersioning. I also have a PWA application. How can I configure my PWA's service-worker.js so that it gets versioned versions of app.js and app.css files? Currently they no longer match since names are changed via versioning.
The AI immediately provided two viable approaches:
- Webpack Encore integration with dynamic variable replacement during the build process
- Post-build scripts that update files after compilation completes
What’s impressive is that the AI actually anticipated a potential issue, predicting that certain files wouldn't be available at build time and recommending the post-build approach as the more robust solution. Beyond the initial suggestions, Claude provided:
- A working PHP controller for dynamic manifest.json generation across multiple domains
- Specific Webpack Encore configuration extensions with appropriate plugins
- Complete post-build script implementations for variable replacement
- Node.js script modifications for PostCSS integration
Each suggestion came with functional code that required minimal modification to work in the actual project environment.
Results
- Estimated time: 2+ days (16+ hours)
- Actual completion time: 5 hours
- Time saved: 68% reduction from original estimate
<div class="rtb-text-box is-blue-50">Although one suggested approach turned out to be a dead end, the overall guidance and working code samples significantly accelerated the project. The AI's ability to provide domain-specific solutions for an uncommon integration challenge proved invaluable when traditional resources and team expertise weren't available.</div>
Case #2: Extending stimulus components with additional features
A developer working on a Symfony/Sylius project with Stimulus faced a common dilemma: off-the-shelf component libraries provide solid foundations but often fall short of specific project requirements. Two particular challenges emerged that required extending existing functionality in ways not covered by standard documentation.
Example 1: Shadow DOM integration with Turbo Frames
The project needed Stimulus/Hotwire Turbo Frames to work seamlessly with Shadow DOM - a complex integration requiring:
- TypeScript type declarations for turbo-frames that didn't exist globally
- Logic to detect when turbo-frames were active and reconfigure accordingly
- Proper TypeScript project setup to handle custom global variables
This wasn't just a coding problem but a project configuration challenge. TypeScript's strict typing requirements meant that even small oversights in setup could break the entire implementation.
The AI-assisted solution
The developer described the specific issues to the AI: missing global type definitions and the need for conditional turbo configuration. The key advantage was the AI's ability to maintain full conversation context, allowing the developer to share multiple configuration files and receive targeted solutions.
Instead of generic Stack Overflow answers that rarely match specific project setups, the AI provided solutions tailored to the exact TypeScript configuration and project structure being used.
Results
- Time taken: 1 hour
- Alternative approach: Hours of Stack Overflow research with uncertain outcomes
- Key benefit: Context-aware solutions that worked with the specific project setup
Example 2: Dynamic tooltip with auto-positioning
The project required a tooltip component with:
- Automatic positioning based on viewport constraints
- Dynamic arrow positioning pointing to target elements
- Integration with the existing Stimulus/TypeScript architecture
While the developer had some familiarity with Popper.js (the industry-standard positioning library), implementing a complete solution from scratch would require significant documentation diving and foundational code setup.
The AI-assisted solution
By describing the requirements and specifying the technology stack (TypeScript, Stimulus, Popper.js), the developer received a complete component class that handled:
- Opening and closing state management
- Popper.js integration for intelligent positioning
- Arrow calculation and movement logic
- Proper TypeScript typing throughout
Results
- Actual time: 2 hours (including refinements)
- Estimated manual time: 4+ hours
- Time reduction: Approximately 50%
The AI eliminated the most time-consuming aspects of the task, including:
- Writing repetitive state management code for tooltip visibility
- Researching and implementing Popper.js configuration
- Creating the mathematical logic for arrow positioning
- Ensuring proper TypeScript integration throughout
<div class="rtb-text-box is-blue-50">While the generated code still required refinement and project-specific adjustments, the foundational structure was solid and functional, allowing the developer to focus on customization rather than basic implementation.</div>
Case #3: Moving logic from TWIG to PHP
A frontend developer had implemented language switching functionality directly in a Twig template, handling several complex requirements:
- Locale detection and processing
- Dynamic language flag display with specific replacements (US flag swapped for UK, etc.)
- URL generation that preserved all current page parameters while only changing the language
The solution worked perfectly, but the code review correctly identified an architectural issue: business logic should belong in PHP, not in the template layer.
The challenge
This feedback came on a Thursday afternoon, with the developer planning Friday off. The fix needed to happen quickly, but it involved:
- Creating a proper PHP Twig extension
- Converting Twig syntax and logic to PHP equivalents
- Maintaining all the existing functionality while restructuring the code
- Ensuring the refactored solution integrated properly with the existing template
For a frontend developer who works with PHP occasionally but isn't deeply fluent in its conventions and best practices, this represented a potentially time-consuming task.
The AI-assisted solution
The developer took a direct approach: paste the relevant Twig template sections into the AI and request a PHP Twig function implementation. The AI delivered:
- Complete class skeleton following PHP/Symfony conventions
- Accurate logic conversion from Twig syntax to PHP equivalents
- Working implementation that required minimal adjustments
- Proper integration with the existing Twig template system
Results
- Implementation time: 20 minutes
- Code review resolution: Same day, before the end of work
- Holiday plans: Preserved without weekend work
<div class="rtb-text-box is-blue-50">This case shows how effective AI can be when you need to convert working code from one language to another, especially under time pressure. The AI didn't just translate the syntax - it also made smart decisions about how to structure the PHP code properly, saving the developer from having to research PHP conventions and best practices. For developers who work across different technologies, AI can act as a reliable translator that understands both languages and can bridge the gap while preserving functionality.</div>
https://bitbag.io/blog/ai-ecommerce-personalization
Case #4: Yaml Symfony translations modifications
During a Symfony project evolution, translation keys that were originally functional but poorly named needed systematic updates to follow better naming conventions. This is a common scenario as projects mature - what starts as quick, descriptive keys like user_login_error or cart_checkout_button evolves into more structured, hierarchical naming patterns.
The developer faced a large YAML translation file containing numerous keys that needed to be renamed according to new project standards for clarity and maintainability.
The AI-assisted solution
Rather than manually scanning through hundreds of translation entries, the developer pasted the entire translation file into the AI, with new naming pattern/convention requirements.
The AI successfully:
- Scanned the complete file regardless of size
- Identified target entries that matched the refactoring criteria
- Applied the new naming pattern consistently across all relevant keys
- Preserved translation content while updating the key structure
Results
- AI-assisted time: 30 minutes
- Estimated manual time: 90+ minutes
- Efficiency gain: 67% time reduction
<div class="rtb-text-box is-blue-50">The remaining work involved updating Twig templates to use the new translation keys - a task that still required human judgment to locate and verify each usage context. This case perfectly demonstrates what AI does best: spotting patterns and applying them consistently across large amounts of data. Unlike humans, AI doesn't get tired or make inconsistent changes halfway through a big file, and it can process hundreds of entries without the mind-numbing tedium of manual find-and-replace work.</div>
Wrapping Up
After tracking these four real projects, the pattern is pretty straightforward: AI isn't just making our developers faster, but also it's changing how they tackle the tricky stuff. We're seeing consistent time savings of 50-68% on tasks that used to be major time sinks.
What's really interesting is that AI shines brightest on exactly the problems that usually slow our team down: those weird integrations nobody's done before, converting code between languages, and setup tasks that happen so rarely that even our senior devs have to look things up. Instead of replacing our expertise, AI handles the tedious groundwork so our developers can focus on the actual problem-solving.
The technology is evolving fast and clearly has way more potential ahead. Plus, it's always worth asking AI for alternative approaches, as sometimes it suggests solutions we wouldn't have thought of ourselves.
{{cta-service="/comp/cta"}}
