Shipping Solutions at AI Speed

Six months ago, I would scope a client project at 3-4 weeks minimum. Landing page redesign? Two weeks. Custom dashboard with real-time data? Three weeks, maybe four if we're being honest about edge cases. Authentication system with role-based permissions? God forbid we need to explain why that's a month-long engagement.

Today? I shipped a complete analytics dashboard with AI-powered insights, PDF export, and role-based access control in four days. Not a prototype—production code, deployed, earning client revenue.

This isn't about writing faster. It's about operating at a fundamentally different velocity.

The Shift That Actually Mattered

I've been playing with AI coding assistants since GitHub Copilot launched. The early stuff was... fine? Autocomplete on steroids. Occasionally impressive, frequently wrong, always requiring heavy editing. I used it the way most developers did: as a slightly smarter snippet generator.

The shift happened quietly. Somewhere between Claude Opus 4 and the latest Sonnet releases, the expectation flipped. I stopped hoping the generated code would work and started expecting it. When it doesn't work on the first try, I'm genuinely surprised—and it's usually because I gave lazy context.

The bottleneck is no longer "can AI write this code?" The bottleneck is me:

• How clearly can I articulate what needs building?
• How well do I understand the system architecture?
• How fast can I review and integrate the changes?

This matters enormously for consultancy work. Client projects live or die on velocity and quality. Ship faster without sacrificing quality? That's not just a competitive advantage—it's a different business model.

What Changed in Practice

From Micromanagement to Architecture

I used to write most code myself. Now I spend 70% of my time on architecture decisions:

• Which dependencies make sense for this client's maintenance capacity?
• Should this be serverless or containerized given their team's expertise?
• What's the simplest possible implementation that meets requirements?

The AI handles the implementation. I handle the "what" and "why"—the machines handle the "how."

Example: A client needed a content management system for their marketing team. Old workflow:

1. Research headless CMS options (3-4 hours)
2. Set up Next.js with the chosen CMS (4-6 hours)
3. Build custom components for their content types (8-10 hours)
4. Implement preview mode and webhooks (6-8 hours)
5. Create admin interface customizations (4-6 hours)

Total: ~30 hours minimum, probably 35-40 with debugging.

New workflow:

1. Evaluate CMS options with AI assistance, focusing on maintenance burden (1 hour)
2. Describe the content model and desired features to Claude (30 minutes)
3. Review generated implementation, fix edge cases, customize styling (3-4 hours)
4. Deploy and train the client (1 hour)

Total: ~6 hours. Same quality, 83% less time.

The client doesn't care that AI wrote the code. They care that their marketing team can now update content without developer intervention, and they paid for one day instead of a week.

Tool Selection is Everything

Here's something nobody talks about: language and framework choice now depends heavily on what AI models handle well.

For consultancy projects, I've standardized on:

• TypeScript/Next.js for web applications (Sonnet crushes React patterns)
• Go for CLIs and backend services (excellent AI support, easy client handoffs)
• Python for data processing and automation (models understand it natively)

I used to choose technologies based on performance characteristics or ecosystem maturity. Now? "What will generate clean, maintainable code with minimal revision cycles?"

This isn't selling out—it's pragmatism. Clients don't care if I personally prefer Rust. They care about delivery speed and maintenance burden. If TypeScript gets me to production in 1/4 the time with code their team can maintain, that's the right choice.

Real Projects, Real Velocity

Let me get specific. Here are three recent client projects and how AI assistance changed delivery:

Project 1: Financial Analytics Dashboard

Client need: Visualize transaction data from multiple sources, generate monthly reports, export to PDF.

Traditional estimate: 3 weeks

• Week 1: Data pipeline setup, API integrations
• Week 2: Dashboard UI, chart implementations
• Week 3: PDF generation, polish, bug fixes

Actual delivery: 4 days

• Day 1: Architecture planning, data schema design (with AI assistance for schema validation)
• Day 2: AI-generated data pipeline with error handling, integration tests
• Day 3: Dashboard UI using shadcn components, Recharts integration, all AI-generated
• Day 4: PDF export implementation, client feedback incorporation, deployment

Key insight: I spent most of my time on data modeling and UX decisions. The AI handled the tedious parts—fetch logic, chart configurations, PDF layout calculations.

Project 2: Multi-tenant SaaS Authentication

Client need: White-label authentication system with role-based permissions, SSO support, audit logging.

Traditional estimate: 4-5 weeks (this is genuinely complex)

• Weeks 1-2: Auth system architecture, database design
• Week 3: Role/permission implementation, SSO integration
• Week 4: Audit logging, admin interface
• Week 5: Testing, security review, bug fixes

Actual delivery: 9 days

• Days 1-2: Architecture decisions (Clerk vs. Auth0 vs. custom, ultimately chose Clerk for client's use case)
• Days 3-5: AI-implemented role system, permission middleware, audit logging
• Days 6-7: Admin interface for tenant management (mostly AI-generated)
• Days 8-9: Security review (manual), testing, client training

Key insight: I made the hard decisions (auth provider, multi-tenancy approach). AI handled the implementation details. Security review was still manual—some things you don't delegate.

Project 3: Content Migration Tool

Client need: Migrate 10,000+ articles from WordPress to a headless CMS, preserve SEO metadata, handle image optimization.

Traditional estimate: 2-3 weeks

• Week 1: Export scripts, data transformation logic
• Week 2: Import scripts, error handling, retry logic
• Week 3: Image processing, validation, manual cleanup

Actual delivery: 3 days

• Day 1: Migration strategy planning, schema mapping
• Day 2: AI-generated export/transform/import pipeline with robust error handling
• Day 3: Image optimization pipeline, validation scripts, successful migration

Key insight: Data transformation is tedious and error-prone for humans. AI excels at this—pattern matching, edge case handling, schema mapping. I focused on validation logic and success criteria.

The Workflow That Actually Works

Here's my current process for client projects:

1. Deep Client Discovery (Still Human)

• What's the actual problem? (Not what they think they want)
• Who maintains this after I'm gone?
• What's their technical capacity?
• What's the simplest solution that works?

This hasn't changed. AI doesn't help with client psychology.

2. Architecture First (Human + AI)

• I make the big decisions: deployment strategy, core dependencies, data architecture
• AI helps evaluate options: "Compare Prisma vs. Drizzle for a team with limited ORM experience"
• We collaborate on edge cases: "What happens if the API goes down mid-transaction?"

3. Implementation (Mostly AI)

• I describe features in plain English with context
• AI generates implementation
• I review for security issues, performance problems, maintainability

Critical: I don't read much code anymore. I read diffs, understand data flow, verify security practices. The days of line-by-line code review are gone.

4. Integration Testing (Human)

• Manual testing of critical paths
• Security verification
• Performance validation

AI helps generate test cases, but I verify manually. Some things are too important to delegate.

5. Client Handoff (Human)

• Documentation (AI-assisted)
• Training (human)
• Ongoing support planning (human)

What This Means for Consultancy

The business model of software consultancy is changing:

Old model:

• Charge by the hour or sprint
• More complex = more billable hours
• Profitability tied to utilization rates

New model:

• Charge by the outcome or project
• Faster delivery = more projects per quarter
• Profitability tied to velocity and value delivery

I'm not charging clients less because AI helps me ship faster. I'm delivering more value in less time and charging for that value.

Example: A client pays $15K for a custom dashboard. Whether that takes me 40 hours or 10 hours is irrelevant to them—they got their dashboard. But I can now take on 3-4 projects per month instead of 1-2.

The math is simple:

• Old model: 2 projects/month × $15K = $30K/month
• New model: 4 projects/month × $15K = $60K/month

Same or better quality, same client satisfaction, double the revenue.

The Hard Parts That Haven't Changed

AI assistance doesn't magically solve:

1. Client Communication

Understanding what clients actually need (vs. what they say they need) is still hard. Maybe harder, since I can say "yes" to more things technically.

2. Architecture Decisions

Which database? Monolith or microservices? Client-side or server-side rendering? These decisions have long-term consequences. AI can analyze options, but the decision is mine.

3. Security Review

I don't trust AI-generated code blindly, especially for authentication, payment processing, or data privacy. Manual security review is non-negotiable.

4. Performance Optimization

AI can generate fast code, but it doesn't understand your specific performance requirements or constraints. Profiling and optimization are still manual.

5. Client Relationships

Obvious but worth stating: AI doesn't build trust with clients. That's still human work.

Looking Forward

This is the early phase. Models are getting better weekly. Inference times are dropping. Context windows are expanding.

Prediction for 2026:

• Most consultancy engagements will be measured in days, not weeks
• The bottleneck will be client decision-making, not implementation
• Differentiation will come from taste, architecture decisions, and client relationships—not coding speed

What I'm watching:

• Models that understand and modify existing codebases (not just generate new code)
• AI that can debug production issues by analyzing logs and metrics
• Tools that translate client requirements into working software with minimal human intervention

We're not there yet. But the trajectory is clear.

Practical Advice

If you're doing consultancy work or client projects:

1. Embrace It Now

The competitive advantage is real. Clients who get their solutions in days instead of weeks will choose you over slower competitors.

2. Invest in Architecture Skills

Your value is shifting from "I can code this" to "I know what should be built and how it should work." Double down on system design, dependency evaluation, and client communication.

3. Standardize Your Stack

Pick technologies that AI handles well and stick with them. Every project on the same stack compounds your velocity advantage.

4. Update Your Pricing Model

If you're still billing hourly, you're leaving money on the table. Move to value-based or project-based pricing.

5. Focus on Security and Performance

These are your human-verification checkpoints. Don't skip them.

The Real Shift

This isn't about AI replacing developers. It's about developers who embrace AI replacing developers who don't.

Six months ago: I was a developer who coded. Today: I'm an architect who builds using AI.

The code quality is better. The delivery speed is faster. The client satisfaction is higher.

And honestly? The work is more interesting. I spend time on problems that matter—client needs, system architecture, user experience—instead of fighting with CSS grid layouts or writing the 47th API endpoint this month.

This is what shipping at AI speed looks like. The inference happens in seconds. The delivery happens in days instead of weeks.

The consultancy game has changed. Are you playing the new game, or still optimizing for the old one?

---

Interested in working with a consultancy that operates at AI speed? Get in touch and let's ship your project faster than you thought possible.