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

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:

1. System architecture: Designing the overall structure of applications
2. AI collaboration: Effectively guiding AI tools with well-crafted prompts
3. Verification and integration: Ensuring AI-generated solutions actually work together
4. 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:

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

Balancing speed vs. depth

To ensure I still developed proper understanding:

1. After implementing an AI-suggested solution, I'd ask it to explain how the code works
2. For critical sections, I'd deliberately rewrite portions without AI assistance
3. I'd use AI to generate test cases to verify my understanding
4. 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:

1. Craft clear requirements and architectural vision
2. Effectively communicate with both humans and AI
3. Verify and integrate AI-generated solutions
4. Understand business contexts and user needs
5. 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

---

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.

*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!