DEV Community: Kevin Craig

Claude Code: Beyond the Rubber Duck - How AI Assistants Are Reshaping Development Workflows

Kevin Craig — Tue, 17 Jun 2025 17:06:24 +0000

A developer's honest take on the current state and future of AI-assisted coding

TL;DR: After weeks of hands-on experience with Claude Code, I've hit token limits 3x in one day but achieved near-autonomous development workflows. Enterprise AI adoption is slower than expected, but the productivity gains for early adopters are substantial. Here's what I've learned building a 98% AI-generated social network.

Key Takeaways

Claude Code enables truly autonomous development workflows once initial permissions are configured
Token consumption is the biggest limitation - expect to hit usage caps frequently during intensive sessions
Enterprise adoption remains cautiously slow - opportunity for early adopters to gain competitive advantage
Strategic prompt planning in Claude Web + execution in Claude Code creates powerful development pipelines
AI assistants have evolved beyond rubber duck debugging into genuine problem-solving partners

The Agentic Revolution is Here

After spending the last few weeks deep in a new project using Claude Code, I'm convinced we've crossed a significant threshold in AI-assisted development. This isn't just another coding assistant—it's the beginning of truly agentic programming where AI can take ownership of complex tasks with minimal human intervention.
For context, I'm building a modular social network application inspired by the BBS (Bulletin Board System) era—think customizable communities before the modern internet existed. My goal? Achieve 98% AI-written code, starting with a simple "hello world" and scaling up to a full-featured platform.

The Current State: Impressive Capabilities, Real Limitations

What's Working Remarkably Well

Autonomous Task Execution: Once you've worked through the initial permission requests (and there are many), Claude Code operates with surprising independence. I can provide a detailed prompt—often developed through conversations in Claude Web first—and watch it execute complex workflows with minimal intervention.

Strategic Planning Integration: The most powerful workflow I've discovered involves using Claude Web to break down project requirements into weekly prompt sequences. This strategic planning phase, combined with Claude Code's execution capabilities, creates a development pipeline that feels genuinely collaborative rather than just assistive.

Beyond the Rubber Duck: Every developer knows the value of explaining problems to an inanimate object. AI assistants, particularly Claude Sonnet 4, have evolved far beyond this. Instead of talking to myself, I'm engaging in genuine problem-solving dialogues that often lead to solutions I wouldn't have considered.

The Reality Check: Token Economics

Here's the honest downside—token consumption is aggressive. As a Claude Pro user, I've hit usage limits three times in a single day. When you're in flow state and suddenly hit a wall because your AI assistant needs to recharge, it's jarring. The promise of uncapped workflows can't come soon enough.

Enterprise Adoption: The Cautious Crawl Forward

Having navigated two job searches in the past year, I've observed something fascinating about AI adoption patterns across organizations:

The Resistance Patterns: Many development teams seem determined to find fault with AI tools rather than understanding their current capabilities and limitations. There's a peculiar psychological barrier where some engineers approach AI assistants as competitors rather than force multipliers.

The Slow Enterprise Pivot: Small and large companies alike are taking a wait-and-see approach. Based on conversations across the industry, I predict the second half of 2025 will mark a significant acceleration in enterprise AI adoption. The organizations that figure this out first will have a substantial competitive advantage.

The BBS Project: A Perfect AI Test Case

My current project—a modular social network platform inspired by BBS systems—serves as an ideal testing ground for AI-assisted development. For younger developers who might not remember: BBSs were the internet before the internet. Single phone lines, dial-up modems, one user at a time (maybe three if you were fancy), and communities built around shared interests discovered through word of mouth.
The modern parallel I'm building maintains that spirit of customizable, focused communities. Want a social network dedicated to underwater basket weaving? The modular architecture should make that possible. It's simultaneously an experiment in AI-generated code and a return to the focused, interest-driven communities that made early online spaces special.

Practical Insights for Developers

The Permission Dance

Expect significant upfront time investment in training Claude Code on your preferences and security boundaries. This initial permission phase feels tedious but pays dividends in autonomous operation later.

Strategic Prompt Development

Don't underestimate the value of using Claude Web first for project planning. The ability to have detailed architectural discussions and then translate those into actionable prompts for Claude Code creates a powerful development pipeline.

Token Management Strategy

For heavy users, develop workflows that batch related tasks. Running out of tokens mid-flow is productivity death. Plan your AI-intensive work around usage patterns and have fallback strategies.

Should Engineers Be Worried?

Not yet, and here's why: enterprise adoption remains cautiously slow, and the technology still requires significant human oversight and strategic thinking. The engineers who should be concerned are those refusing to engage with these tools at all.
The immediate impact isn't job displacement—it's productivity multiplication for those who learn to work effectively within current AI capabilities. The developers who master AI-assisted workflows today will be the ones defining best practices as adoption accelerates.

The Path Forward

We're in a unique moment where AI coding assistants have become genuinely useful while remaining clearly bounded in their capabilities. Claude Sonnet 4 represents a significant step forward in reasoning and code generation, but it's still very much a tool that requires skilled operation.
The developers who thrive in this environment will be those who:

Understand AI capabilities and limitations deeply
Develop effective prompt engineering skills
Learn to architect projects that leverage AI strengths
Maintain critical thinking about generated code
Stay adaptable as the technology evolves rapidly

Looking Ahead

My BBS-inspired social network project will serve as a real-world stress test for current AI-assisted development capabilities. I'll be documenting the journey, tracking what percentage of code is truly AI-generated, and identifying where human intervention remains essential.
The goal isn't to prove AI can replace developers—it's to understand how we can work together more effectively. As I progress through this experiment, I'm convinced we're witnessing the early days of a fundamental shift in how software gets built.
The rubber duck era is ending. The age of AI pair programming has begun.

About the Author

I'm currently a Senior Software Engineer at Kelly Services, bringing over 25 years of experience that spans both infrastructure and development disciplines. The last 8+ years have been spent in the startup ecosystem, where I've witnessed firsthand how technology adoption patterns vary dramatically between nimble startups and established enterprises.
This unique perspective—combining deep technical experience with recent exposure to both emerging companies and traditional corporate environments—has given me valuable insights into how AI tools like Claude Code are being received across different organizational contexts. My career has taught me that the most impactful technologies often face initial resistance before becoming indispensable, and I believe we're seeing that pattern play out with AI-assisted development tools today.

Engagement Questions

For the community:

What AI coding tools are you currently using, and how do they compare to your experience with traditional IDEs?
How is your organization approaching AI tool adoption? Are you seeing resistance or enthusiasm?
What percentage of your current projects could realistically be AI-assisted?

Connect with me if you're experimenting with AI-assisted development or want to discuss enterprise adoption strategies. I'm particularly interested in hearing from other developers who are pushing the boundaries of what's possible with current AI tools.

#AI #SoftwareDevelopment #ClaudeCode #DeveloperProductivity #TechTrends #Coding #ArtificialIntelligence #SoftwareEngineering #DevTools #Innovation

AI & The Future of Software Engineering: Rebuilding Legacy ERPs with AI Assistance

Kevin Craig — Wed, 09 Apr 2025 19:17:27 +0000

Part 3 of "Navigating the New AI Landscape in Software Development"

Introduction

Throughout this series, I've explored how AI is transforming software development—first through my productivity experiment demonstrating 10x efficiency gains, then by sharing the advanced prompting techniques that made those gains possible. Now, let's turn to one of software engineering's most challenging domains: working with legacy applications.

As many of us know all too well, legacy systems present unique challenges. They're often poorly documented, built on outdated technologies, and maintained by teams that have long since moved on. Yet these systems frequently form the backbone of critical business operations. In my 30 years in the industry, I've found few tasks more daunting than modernizing these digital artifacts from another era.

But here's the exciting part: AI tools are proving to be remarkably effective allies in this challenging domain. Let me share what I've discovered.

The Legacy Challenge

Legacy small business ERPs typically come with several obstacles:

Monolithic architectures built on outdated frameworks
Tightly coupled UI and business logic
Complex database schemas with undocumented relationships
Business processes embedded in code rather than configuration
Limited extensibility for modern integrations

Before AI, modernizing these systems often meant months of archaeological code exploration, risky rewrites, and painstaking testing. Today, the landscape is rapidly changing.

How AI Changes the Legacy Modernization Equation

Consider a hypothetical scenario: modernizing a 12-year-old small business ERP originally built with jQuery and PHP. AI tools could dramatically accelerate several aspects of this process:

Code comprehension: AI can analyze and explain complex legacy code segments in minutes rather than hours
Documentation generation: Creating missing documentation becomes semi-automated
Modernization planning: AI can help identify modernization pathways and potential risks
Code transformation: Converting from PHP/jQuery to React/TypeScript with significantly less manual coding

Let me walk you through how the PREP method (introduced in Part 2) could be applied to this specific challenge.

The PREP Method Applied to Legacy Systems

As a reminder, the PREP method consists of:

Problem definition: Clearly articulate what you're solving

Requirements specification: List constraints and expectations

Example integration: Show how this fits into your larger system

Pattern suggestion: Guide the AI toward preferred approaches

Here's how this framework could be adapted specifically for legacy ERP work:

Problem Definition for Legacy ERPs

When working with legacy ERPs, providing precise context is crucial. For example, rather than asking "How do I modernize this code?", you'd get much better results with:

"I need to modernize this PHP/jQuery ERP application that uses server-rendered pages and AJAX calls for data updates. The inventory management module uses a complex set of database tables with triggers and stored procedures. I need to convert this to a React/TypeScript frontend with a RESTful API backend."

The specificity helps the AI understand exactly what technologies are involved and what you're trying to accomplish.

Requirements Specification for Legacy ERPs

With legacy ERPs, constraints become particularly important. You should typically include:

Which business processes must remain unchanged
Performance expectations, especially for data-heavy operations
Authentication and authorization requirements
Data migration approach
Training considerations for users

Example Integration for Legacy ERPs

For legacy ERP work, providing code snippets from multiple parts of the system helps the AI understand interdependencies. You would typically share:

UI components and their corresponding backend code
Database schemas and queries
Business logic implementations
Integration points with other modules

Pattern Suggestion for Legacy ERPs

This is where you guide the AI toward your preferred modernization approach. You would typically specify:

React component structure and state management approach
TypeScript typing strategy for business entities
API design patterns
Testing methodology

Hypothetical Example: Modernizing an Inventory Management Module

Let's imagine modernizing an inventory management module from a PHP/jQuery ERP built in 2011. The original code used server-rendered tables with jQuery for interactivity and a mix of raw SQL and stored procedures.

Here's how you might structure your prompt:

I need to modernize this PHP/jQuery inventory management module to use React, TypeScript, and a RESTful API.

The module handles product inventory with these requirements:
- Must maintain all existing inventory adjustment types (purchase, sale, return, etc.)
- Must support batch operations for efficiency
- Must improve search and filtering capabilities
- Must maintain audit trail for all inventory changes
- Should allow offline capability for inventory counts

Here's the core inventory management code:
[code snippet of the original PHP implementation]

Here's the database schema:
[SQL schema for inventory tables]

It integrates with these other modules:
[code snippets showing integration with sales and purchasing]

I'd like to use React with TypeScript, following these patterns:
- React Query for data fetching and caching
- Zod for runtime type validation
- Context API for state management
- Headless UI components for accessibility
- RESTful API endpoints with consistent error handling

This approach could yield remarkable results. The AI might:

Analyze the existing business logic and data flow
Propose a component hierarchy for the React frontend
Design TypeScript interfaces for all inventory entities
Generate API endpoint specifications
Create example React components for key functionality

What would typically take weeks of refactoring could be completed in a couple of days. You'd still need to review, test, and refine the generated code, but the productivity gain would be substantial.

Strategies for Different Legacy Challenges

Here are some specialized approaches for common ERP challenges:

1. Deciphering Complex Business Rules

When facing complicated business logic:

Ask the AI to analyze the code and identify the business rules being implemented
Request a separation of presentation logic from business logic
Have the AI generate test cases that would verify these behaviors
Use this understanding to guide the React component design

2. Handling Data-Intensive Operations

For modules with complex data processing:

Have the AI analyze the existing queries and data flow
Request optimized API endpoints that minimize data transfer
Design React components that efficiently render and update large datasets
Implement proper loading states and error handling

3. Migrating from Monolith to Microservices

When breaking up a monolithic ERP:

Use the AI to identify module boundaries and dependencies
Design API contracts between services
Create React components that can consume multiple APIs
Implement proper state management for cross-module data

Measuring Success

Modernization projects can easily go off track without clear metrics. Success could be measured through:

User experience improvement: Has the modernization made the system more intuitive and efficient?
Performance gains: Are operations faster in the new system?
Maintainability: Is the new code more accessible to the current development team?
Extensibility: How easily can we add new features or integrations?
Time saved: How much faster was the AI-assisted approach compared to traditional methods?

In our hypothetical project, we might achieve an 80% reduction in modernization time while significantly improving performance and user experience. Business users would likely report that the new inventory system was much more responsive and easier to use.

The Human Element Remains Critical

Despite these advances, the human element remains irreplaceable. AI excels at code transformation but struggles with:

Understanding the unwritten business processes behind the code
Identifying user pain points that should be addressed during modernization
Balancing technical improvements with user training needs
Making architectural decisions that align with company growth plans

The most effective approach combines AI's ability to rapidly process and transform code with human judgment about what should be preserved, enhanced, or redesigned.

Looking Forward

As AI tools continue to evolve, they'll become increasingly valuable for legacy ERP modernization. Future capabilities might include:

Automatic generation of data migration scripts
User interface patterns based on usage analytics
End-to-end testing against existing system behavior
Guided refactoring that preserves complex business rules while improving architecture

For experienced engineers like myself, these tools don't threaten our relevance—they amplify our impact. They allow us to focus on the strategic and creative aspects of software engineering while accelerating the mechanical parts of modernization.

Conclusion

Legacy ERP modernization has traditionally been one of software engineering's most challenging domains. With AI assistance, we're seeing a fundamental shift in how these projects can be approached—making them faster, less risky, and more likely to succeed.

By applying structured methods like PREP to legacy challenges, engineers can leverage AI to transform outdated systems into modern, maintainable React/TypeScript applications without losing the critical business logic embedded within them.

In the final article of this series, I'll explore how to design new systems specifically for AI-human collaboration, creating architectures that will remain adaptable as both business needs and AI capabilities evolve.

This is the third article in my series "Navigating the New AI Landscape in Software Development." If you missed the previous installments about my productivity experiment with AI tools or advanced prompting techniques, you can find them [here].

What's been your experience modernizing legacy applications? Have you tried using AI tools for this purpose? Share your thoughts in the comments.

About the author: I'm a software engineer with 10 years of dedicated engineering experience and nearly 30 years in the IT industry overall. My career has spanned organizations of all sizes—from large corporations like Nortel (a major Cisco competitor in its day) to most recently a startup with just 6 employees. Currently seeking my next opportunity, I'm deeply invested in understanding how AI is reshaping our industry and what it means for experienced engineers like myself.

AITools #SoftwareDevelopment #LegacyModernization #ReactTypescript #SmallBusinessERP

AI & The Future of Software Engineering: Advanced Prompting Techniques for 10x Efficiency

Kevin Craig — Fri, 28 Mar 2025 18:00:41 +0000

Introduction

In my previous article, I shared my experiment demonstrating how AI tools allowed me to build an application with an unfamiliar cloud service in just a week and a half—a task that would have typically taken me 10-15 times longer using traditional development methods. The response was overwhelming: many of you reported similar productivity gains, with some achieving even faster development cycles and improved code quality through strategic AI prompting techniques. Others shared struggles with inconsistent results and the challenge of getting AI to produce production-ready code.

Today, I'm focusing on the how—the specific prompting techniques and strategies that can help you consistently achieve these dramatic efficiency gains. As AI becomes integral to our development workflow, prompt engineering is emerging as a critical meta-skill that separates highly productive developers from the rest.

The Evolution of Developer-AI Collaboration

We've quickly moved beyond basic code completion. Today's AI tools can generate entire components, troubleshoot complex issues, and even suggest architectural approaches. Yet many developers still experience frustration when their prompts yield generic, often incorrect results.

The difference between mediocre and exceptional AI output almost always comes down to how you frame your requests. Just as clear requirements lead to better human-written code, well-crafted prompts lead to better AI-generated solutions.

Key Principles of Effective AI Prompting for Developers

1. Contextual Anchoring & Rules-Based Frameworks

Before requesting any code, provide precise project context. Let's look at a concrete example:

// Weak prompt:
Write a user authentication system using Firebase.

// Strong prompt:
I'm building a React Native mobile app (Expo SDK 48) with Firebase backend. We need a user authentication system that supports:
- Email/password login
- Google OAuth
- Phone verification

The app uses Redux for state management and follows Material Design guidelines. We handle form validation with Formik and Yup. The authentication state should persist between app launches.

Here's how we've structured our Redux store so far:
{
  user: {
    isAuthenticated: boolean,
    profile: UserProfile | null,
    authError: string | null,
    isLoading: boolean
  }
}

The difference is dramatic. The second prompt gives the AI a clear understanding of your tech stack, design patterns, and specific requirements, resulting in code that integrates seamlessly with your existing project.

Modern IDEs like Cursor are taking this concept even further by implementing rules-based frameworks that let you predefine project context and coding standards. Similarly, platforms like Claude Projects (which is not an IDE, but rather a workspace for organizing conversations and artifacts) allow users to collect and reuse prompt templates and contextual information. Cursor's implementation uses the Model Context Protocol (MCP), which provides a standardized way for AI models to access external context and tools.

For example, you can create a .cursor/rules file for a React Native project:

# React Native Development Standards

You are an expert in React Native development with the following standards:

- Use functional components with hooks, never class components
- Follow atomic design principles for UI components
- Use TypeScript for type safety with proper interfaces for all props
- Implement responsive layouts using React Native's flexbox
- Follow the project's established folder structure:
  - /src/components - UI components
  - /src/screens - Screen components
  - /src/navigation - Navigation configuration
  - /src/hooks - Custom hooks
  - /src/utils - Helper functions
  - /src/services - API clients and services
  - /src/store - Redux store setup and slices

Reference our standard imports:
- `import { colors, spacing } from '../theme';`
- `import { useAppDispatch, useAppSelector } from '../hooks';`

These rules are automatically applied whenever the AI generates code for matching files, ensuring consistency across your codebase. Resources like cursordirectory.com offer collections of pre-built rules for various frameworks and languages.

2. Constraint Definition

Explicitly state your boundaries and requirements:

// Additional constraints to add to your prompt:
The solution must:
- Be optimized for mobile performance (minimize bundle size)
- Include appropriate error handling for network issues
- Follow security best practices (e.g., token refresh, secure storage)
- Use functional components and hooks (no class components)
- Include TypeScript type definitions
- Follow our project's eslint configuration (we use Airbnb style guide)

The more specific your constraints, the more tailored the output will be to your needs.

3. Progressive Iteration

Start with architecture before diving into implementation. Here's an effective sequence I use:

First prompt: Request a high-level design/architecture
Second prompt: Ask for implementation of a specific component based on the architecture
Third prompt: Refine the implementation based on specific requirements
Fourth prompt: Ask for tests or edge case handling

Breaking complex systems into manageable chunks like this creates a more manageable workflow and produces better results.

4. Error Resolution Patterns

When AI-generated code doesn't work as expected (and this will happen), these troubleshooting approaches can dramatically improve resolution time:

// Instead of this:
This code doesn't work. Fix it.

// Try this:
When implementing the Google OAuth flow, I'm getting the following error:
[EXACT ERROR MESSAGE]

Here's the relevant code:
[CODE SNIPPET WITH LINE NUMBERS]

I think the issue might be related to how we're handling the auth credentials. Can you:
1. Explain what's causing this error
2. Provide a fixed implementation
3. Explain why your solution fixes the issue

Learning to effectively diagnose issues, escape repetitive error loops, and knowing when to switch tools or approaches is crucial for productive AI collaboration.

Advanced Techniques I've Tested

1. Schema-First Development

This approach has been particularly effective for me. Before asking for implementation, I provide the complete data model:

// Example schema-first prompt:
Here's our PostgreSQL schema for a blogging platform:

CREATE TABLE users (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  email TEXT UNIQUE NOT NULL,
  name TEXT NOT NULL,
  bio TEXT,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

CREATE TABLE posts (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  title TEXT NOT NULL,
  body TEXT NOT NULL,
  user_id UUID REFERENCES users(id) ON DELETE CASCADE,
  published BOOLEAN DEFAULT false,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

CREATE TABLE comments (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  body TEXT NOT NULL,
  user_id UUID REFERENCES users(id) ON DELETE CASCADE,
  post_id UUID REFERENCES posts(id) ON DELETE CASCADE,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

Using Supabase as our backend and Next.js API routes, implement the following:
1. A complete CRUD API for posts
2. Proper error handling
3. Authentication middleware to ensure users can only modify their own posts

This approach gives the AI a precise understanding of your data relationships, making the generated code much more accurate.

2. Test-Driven Prompting

Writing test cases before requesting implementation provides implicit requirements that AI can understand:

// Test-first prompt example:
I need to implement a utility function called `calculateDiscountedPrice` with the following test cases:

describe('calculateDiscountedPrice', () => {
  test('applies percentage discount correctly', () => {
    expect(calculateDiscountedPrice(100, { type: 'percentage', value: 20 })).toBe(80);
  });

  test('applies fixed amount discount correctly', () => {
    expect(calculateDiscountedPrice(100, { type: 'fixed', value: 15 })).toBe(85);
  });

  test('never returns less than zero', () => {
    expect(calculateDiscountedPrice(10, { type: 'fixed', value: 15 })).toBe(0);
  });

  test('handles tiered discounts correctly', () => {
    const tieredDiscount = { 
      type: 'tiered', 
      tiers: [
        { threshold: 0, percentage: 0 },
        { threshold: 50, percentage: 5 },
        { threshold: 100, percentage: 10 }
      ]
    };
    expect(calculateDiscountedPrice(40, tieredDiscount)).toBe(40);
    expect(calculateDiscountedPrice(75, tieredDiscount)).toBe(71.25);
    expect(calculateDiscountedPrice(200, tieredDiscount)).toBe(180);
  });
});

Please implement the calculateDiscountedPrice function that satisfies all these test cases.

This approach is particularly effective because it precisely defines the expected behavior through concrete examples.

3. Comparative Prompting

Asking for multiple solution approaches to the same problem helps you understand tradeoffs:

// Comparative prompt example:
I need to implement a caching layer for API responses in our React application. Please provide three different approaches:

1. A solution using React Query
2. A custom hook implementation with localStorage
3. A Redux middleware approach

For each approach, please include:
- Complete implementation code
- Pros and cons
- Performance considerations
- When this approach would be most appropriate

This technique is excellent for learning and making informed architectural decisions.

4. Multi-Tool Orchestration

I've evolved my workflow over time, and my current approach leverages different tools for their specific strengths:

Cursor: My primary tool for in-IDE completions, project-specific code generation, and day-to-day development. Its context-aware completions and integration with the development environment make it my go-to coding companion.
Claude: I use Claude (Desktop or Web) to create projects that centralize all my conversations and contextual documents before implementation. This becomes my planning and architectural thinking space before I move to Cursor for implementation.
ChatGPT: I rarely use this directly anymore, except occasionally through Cursor's interface when specific capabilities are needed.

This workflow combines the strengths of each tool: Claude's strong reasoning and context management for initial planning, and Cursor's integrated development experience for implementation. The key insight is that different phases of development benefit from different AI interaction patterns.

Practical Framework: The PREP Method

After months of refining my approach, I've developed what I call the PREP method:

Problem definition: Clearly articulate what you're solving
Requirements specification: List constraints and expectations
Example integration: Show how this fits into your larger system
Pattern suggestion: Guide the AI toward preferred approaches

Here's a template I use for complex tasks:

Problem Definition

I need to implement [specific functionality] for [specific purpose].

Requirements

Functional requirements: [list]
Non-functional requirements: [performance, security, etc.]
Must use: [required libraries/frameworks]
Must not use: [prohibited approaches]

System Context

This component will integrate with our system as follows:

Upstream dependencies: [what provides input to this component]
Downstream consumers: [what consumes output from this component]
Related systems: [other systems this interacts with]

Current Implementation / Examples

Here's how we've implemented similar functionality elsewhere:
[code snippet or description]

Preferred Patterns

We prefer to use [specific design patterns] in our codebase.

This framework has consistently yielded higher-quality code with fewer iterations across various projects and AI tools.

Real-World Example: Building a Complex Component with Supabase

Here's a recent example of how I approached building a real-time collaboration feature using Supabase:

Problem Definition

I need to implement a real-time collaborative document editing feature using Supabase's Realtime functionality.

Requirements

Users should see others' cursor positions and selections
Changes should propagate to all connected users within 500ms
The solution should handle conflict resolution
Must work with our existing React/TypeScript frontend
Must use Supabase Realtime (not WebSockets directly)
Should maintain a change history for undo/redo functionality

System Context

We use Supabase for authentication and data storage
Our document editor is built on Slate.js
Document structure is stored in a PostgreSQL table with jsonb

Current Implementation

Here's our current document schema:
[schema details]

Here's how we currently load documents (without real-time):
[code snippet]

Preferred Patterns

We use React Query for data fetching
We prefer custom hooks for encapsulating functionality
We use Zustand for local state management

This detailed prompt resulted in a high-quality implementation that required minimal adjustments to integrate with our system.

Measuring Success: Quality Metrics

Beyond simply "getting the job done," I track the following metrics to evaluate my AI collaboration effectiveness:

Iteration Count: How many prompt-response cycles were needed to get to a working solution
Time-to-Working-Solution: Total time from initial prompt to working implementation
Code Review Feedback: Qualitative feedback from teammates on AI-generated code
Maintainability Score: How well does the generated code conform to our project's style and patterns

Using these metrics, I've been able to refine my prompting techniques and achieve increasingly better results over time.

The Skill Development Curve

Effective prompting improves with deliberate practice. Start with smaller, well-defined tasks and gradually increase complexity as you learn what works. I recommend keeping a "prompt journal" documenting particularly effective or ineffective approaches.

Common pitfalls to avoid:

Being too vague or general
Providing insufficient context
Not specifying constraints clearly
Expecting the AI to infer your specific preferences
Asking for too much in a single prompt

"Vibe Coding" vs. Knowledge-Based Approaches

The term "Vibe Coding" has recently gained popularity in the developer community. Coined by AI researcher Andrej Karpathy in early 2025, it refers to an AI-dependent programming technique where developers describe a problem in plain language and let the AI generate code without fully understanding the implementation details. As defined by Wikipedia, vibe coding "shifts the programmer's role from manual coding to guiding, testing, and refining the AI-generated source code."

While this approach can be incredibly efficient for prototyping and simple applications, I advocate for what I call "Knowledge-Based Vibe Coding." This hybrid approach embraces AI's speed while maintaining a developer's critical understanding of architecture, security implications, and best practices.

Simon Willison, a respected developer, cautions that "vibe coding your way to a production codebase is clearly risky" since most software engineering involves evolving existing systems where code quality and understandability are crucial.

The knowledge-based approach becomes especially important in several scenarios:

// When things break
Instead of: "Fix this error: [paste error message]"
Try: "I'm getting this error: [error message]. I think it's related to how we're handling authentication state. The Redux store might not be properly updated after token refresh. Can you explain what might be happening and suggest a solution?"

// When considering security
Instead of: "Add user registration to my app"
Try: "Add user registration with proper password hashing, email verification, and protection against common vulnerabilities like SQL injection and XSS attacks. Follow OWASP security best practices."

// When thinking about scalability
Instead of: "Create a database for my app"
Try: "Design a database schema that will scale to millions of users with efficient indexing strategies. Consider read/write patterns and potential bottlenecks."

This approach ensures you're leveraging AI's capabilities while maintaining the critical thinking and domain expertise that separates professional developers from those just "vibing" with AI.

Advanced Tools: MCP and RAG Integration

Modern AI-enhanced IDEs are implementing sophisticated frameworks for context management and retrieval:

Model Context Protocol (MCP)

MCP is an open standard designed to facilitate interaction between large language models and external data sources. It establishes a client-server architecture that allows AI coding assistants to access and use additional context beyond what's provided in the prompt.

For example, in Cursor IDE, MCP servers can:

Retrieve API documentation dynamically
Access your project's custom libraries and frameworks
Provide real-time linting feedback
Execute and test code in safe environments
Connect to databases or other systems

Setting up MCP is relatively straightforward. In Cursor, you can configure it in settings:

Settings > Cursor Settings > MCP Servers > Enable

Then add specific MCP servers based on your needs. Popular options include:

GitHub repository access
Documentation retrieval
Web scraping capabilities
Advanced code testing

Retrieval Augmented Generation (RAG)

RAG is another powerful technique that enhances AI by retrieving relevant information from external sources before generating responses. In the context of software development, this means the AI can access your codebase, documentation, and external resources to produce more accurate and contextually appropriate code.

Both MCP and RAG represent the next evolution in AI-assisted development, moving beyond simple prompting to create systems that actively extend the AI's capabilities with external tools and knowledge.

Looking Forward: The Future of Developer-AI Collaboration

As AI capabilities continue to evolve, the relationship between developers and their AI tools will transform. The most valuable skills will increasingly center on:

Architectural thinking and system design
Effective communication with both humans and AI
The ability to orchestrate complex systems rather than writing every line of code
Judgment about when to use AI and when to code manually
Creating and managing effective rules and context systems

Forward-thinking developers are already building shared knowledge bases of effective prompts, rules, and strategies. Resources like cursordirectory.com showcase how the community is optimizing AI-developer collaboration across different frameworks and languages.

In the next article of this series, I'll explore how to leverage AI assistance in rebuilding legacy applications—perhaps one of the most promising applications of these technologies.

This is the second article in my series "Navigating the New AI Landscape in Software Development." If you missed the first installment about my productivity experiment with AI tools, you can find it [here].

What prompting techniques have you found effective in your own development work? Share your experiences in the comments.

AI & The Future of Software Engineering: My 10x Productivity Experiment (Part 1)

Kevin Craig — Wed, 19 Mar 2025 18:23:26 +0000

Like many developers, I've been watching the rapid evolution of AI coding tools with a mixture of fascination and concern. When GitHub Copilot launched, it was interesting but limited. Now, with tools like Cursor, Claude, and ChatGPT, we're seeing capabilities that genuinely impact how we work.

So I decided to run an experiment: build an application using a cloud service I'd never worked with before, relying heavily on AI assistance. The results were sobering, exciting, and thought-provoking all at once.

The Experiment Setup

Goal: Build a fully functional React/TypeScript application using Supabase (a Firebase alternative) as my backend

Tools: Cursor IDE with AI integration, Claude for high-level architecture

Prior knowledge: Zero experience with Supabase

Approach: Rely on AI for:

Initial architecture recommendations
Database schema design in Supabase
Authentication integration with Supabase Auth
Realtime subscriptions setup
Security rule configuration

The Results: 10-15x Productivity Increase

What would have normally taken me 2-3 weeks of intensive work was completed in just over a week. The AI tools helped me:

Generate a complete React/TypeScript project structure with Vite configuration
Set up and configure Supabase tables with proper relationships
Implement row-level security policies in Supabase
Create React hooks for Supabase realtime subscriptions
Configure authentication with multiple providers
Create optimistic UI updates with proper error handling

The productivity gain wasn't just marginal—it was transformative. A task that would have required hours of reading Supabase documentation and browsing GitHub examples was often solved with a well-crafted prompt.

The Technical Challenges: When AI Falls Short

Despite the impressive results, AI isn't a magic solution. I encountered several limitations:

1. The "hallucination" problem

AI would occasionally generate convincing but incorrect solutions. For example, suggesting a non-existent API method for Supabase:

// AI suggested this, but the method doesn't exist in the Supabase API
import { createClient } from '@supabase/supabase-js'

const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)

// This method doesn't exist!
await supabase.from('profiles').createIndex({
  name: 'profiles_username_idx',
  columns: ['username'],
  unique: true
})

// The actual correct implementation needed:
// You would need to create indexes using Supabase's SQL editor or migrations:
// CREATE UNIQUE INDEX profiles_username_idx ON profiles(username);

These hallucinations required vigilant verification against Supabase's official documentation.

2. Context limitations and "ruts"

AI tools have finite context windows and sometimes get stuck in repetitive patterns. I learned to recognize when the AI was in a "rut" and developed tactics to break out of these situations:

// When stuck in a loop like this with Supabase:
AI: "Try adding the RLS policy with this SQL..."
[Adds incorrect policy]
ME: "I'm getting an error: 'relation \"todos\" has no column \"owner\""
AI: "I apologize for the confusion. Let's try a different approach..."
[Suggests nearly identical policy with same error]

// Breaking out with specific tactics:
ME: "Let's step back completely. Here's the exact schema from Supabase Studio:
Table: todos
Columns: 
- id: uuid (primary key)
- user_id: uuid (foreign key to auth.users)
- title: text
- completed: boolean

Given this exact schema, write a complete RLS policy for this table 
that ensures users can only see and modify their own todos."

This often required switching between different AI tools (Claude vs. GitHub Copilot vs. ChatGPT) to get unstuck.

3. Understanding depth trade-off

While I completed the project faster, I didn't develop the same depth of understanding I would have through traditional coding. I found myself implementing patterns without fully grasping their underlying principles:

// AI suggested this Supabase Auth implementation in React
import { useState, useEffect, createContext, useContext } from 'react'
import { createClient, User, Session } from '@supabase/supabase-js'

const supabaseUrl = import.meta.env.VITE_SUPABASE_URL
const supabaseKey = import.meta.env.VITE_SUPABASE_ANON_KEY
const supabase = createClient(supabaseUrl, supabaseKey)

interface AuthContextType {
  user: User | null;
  session: Session | null;
  signIn: (email: string, password: string) => Promise<void>;
  signOut: () => Promise<void>;
  loading: boolean;
}

const AuthContext = createContext<AuthContextType | undefined>(undefined);

export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  const [user, setUser] = useState<User | null>(null);
  const [session, setSession] = useState<Session | null>(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    // Get initial session
    supabase.auth.getSession().then(({ data: { session } }) => {
      setSession(session);
      setUser(session?.user ?? null);
      setLoading(false);
    });

    // Listen for auth changes
    const { data: { subscription } } = supabase.auth.onAuthStateChange(
      (_event, session) => {
        setSession(session);
        setUser(session?.user ?? null);
        setLoading(false);
      }
    );

    return () => subscription.unsubscribe();
  }, []);

  const signIn = async (email: string, password: string) => {
    const { error } = await supabase.auth.signInWithPassword({ email, password });
    if (error) throw error;
  };

  const signOut = async () => {
    const { error } = await supabase.auth.signOut();
    if (error) throw error;
  };

  return (
    <AuthContext.Provider value={{ 
      user, 
      session,
      signIn, 
      signOut, 
      loading 
    }}>
      {children}
    </AuthContext.Provider>
  );
};

export const useAuth = () => {
  const context = useContext(AuthContext);
  if (context === undefined) {
    throw new Error('useAuth must be used within an AuthProvider');
  }
  return context;
};

I could implement and modify this Supabase authentication context, but without the usual research process, I missed nuances about Supabase's auth lifecycle, security edge cases like device management, and how to properly handle multi-tab auth state that I would normally investigate thoroughly.

The Employment Implications

As someone currently between roles with 10 years of software engineering experience (and nearly 30 years in IT overall), the implications are clear to me: these tools will reduce team sizes. One engineer with effective AI tools can now do the work that previously required multiple developers.

My career has spanned organizations of all sizes—from Nortel (a Cisco competitor back in its day) to a 6-person startup most recently. Across all contexts, I can see how these productivity gains translate directly to smaller engineering teams.

But I don't believe AI will replace engineers entirely. Instead, it's shifting the role toward:

System architecture: Designing the overall structure of applications
AI collaboration: Effectively guiding AI tools with well-crafted prompts
Verification and integration: Ensuring AI-generated solutions actually work together
Business context understanding: Translating requirements into technical solutions

Practical Strategies for Working With AI Coding Tools

Through my experiment, I developed several tactics for effective AI collaboration:

Effective prompting techniques

The quality of AI output directly correlates with prompt quality. The difference between these prompts is enormous:

// Poor prompt:
"Write code to handle Supabase authentication in React"

// Effective prompt:
"I need to implement a React authentication system with Supabase and TypeScript that:
1. Uses Supabase Auth with email/password and social login
2. Has a context provider for global auth state
3. Includes protected routes with redirect to login
4. Properly handles session refresh and persistence
5. Includes typing for Supabase user profiles with this schema:

type Profile = {
  id: string;
  user_id: string;
  display_name: string;
  avatar_url: string;
  subscription_tier: 'free' | 'premium' | 'enterprise';
  created_at: string;
};

Please provide the AuthContext, AuthProvider with Supabase integration, useAuth hook, 
and an example of a protected route component using React Router v6.
Make sure to include proper TypeScript types throughout."

Handling AI limitations

I developed a troubleshooting workflow:

If the AI generates non-working code, provide the exact error message
If the AI gets stuck in a loop, reframe the problem from first principles
If the AI doesn't understand a concept, break it down into smaller components
When switching contexts, provide a summary of what's been established so far
For complex architectures, ask the AI to create diagrams before implementation

Balancing speed vs. depth

To ensure I still developed proper understanding:

After implementing an AI-suggested solution, I'd ask it to explain how the code works
For critical sections, I'd deliberately rewrite portions without AI assistance
I'd use AI to generate test cases to verify my understanding
For new concepts, I'd ask the AI to recommend learning resources

Looking Forward: The Evolving Developer

The migration from hands-on coding to architectural thinking is already happening. The future belongs to developers who can:

Craft clear requirements and architectural vision
Effectively communicate with both humans and AI
Verify and integrate AI-generated solutions
Understand business contexts and user needs
Continue learning and adapting to rapidly changing technology

Conclusion

AI won't replace software engineers—but it will transform what software engineering means. The most successful developers will be those who view AI as a powerful collaborator rather than a threat.

My own experience confirms this: I accomplished in days what would have taken weeks, but the process required a new set of skills—knowing how to guide AI tools, when to switch between them, and how to recognize their limitations.

Yes, team sizes will likely shrink, but as with previous technology shifts, new opportunities will emerge for those willing to adapt. As an industry, we're not being replaced—we're being elevated.

Yes I left the mistakes that the Image Generator made on purpose

*This is part 1 of my series "Navigating the New AI Landscape in Software Engineering." Follow me for upcoming articles including:

Part 2: Advanced AI Prompting Techniques for 10x Developer Efficiency
Part 3: Rebuilding Legacy Applications with AI Assistance: A Case Study
Part 4: The New Software Architecture: Designing Systems for AI-Human Collaboration*

Have you experimented with AI coding tools? What productivity gains or challenges have you encountered? Share your experiences in the comments!