Here is what the symbol that has been created from artificial intelligence tells you

IDES IDES intelligently changes how our coding-fastest development, less headache, and immediate suggestions. But there is a technical fact that we need to address:

Amnesty International not only Steeling coding – It is also Speeding insects. 💥

After working with Index, Copilot and Windsurf In different environments, I noticed that artificial intelligence usually does not produce a “wrong” symbol. Instead, it generates technically correct solutions that miss the context of decisive work and know the field.

Here’s what artificial intelligence coding assistants are wrong:

1. Amnesty International provides accurate and difficult performance problems

❌ Amnesty International’s proposal: It seems effective, but it has a problem with hidden N+1

const getUsersWithOrders = async (): Promise => {
  // Fetch all users - seems reasonable
  const users = await prisma.user.findMany({
    where: { status: 'ACTIVE' }
  });
  
  // For each user, get their orders - the subtle N+1 query issue
  const usersWithOrders = await Promise.all(
    users.map(async (user) => {
      const orders = await prisma.order.findMany({
        where: { userId: user.id },
        orderBy: { createdAt: 'desc' },
        take: 5 // Just get recent orders
      });
      return { ...user, orders };
    })
  );
  
  return usersWithOrders;
};

✅ Better solution: one effective query with appropriate relationships

const getUsersWithOrders = async (): Promise => {
  // One efficient query with proper inclusion of related data
  const users = await prisma.user.findMany({
    where: { status: 'ACTIVE' },
    include: {
      orders: {
        orderBy: { createdAt: 'desc' },
        take: 5,
      }
    }
  });
  
  // Server-side data transformation if needed
  return users.map(user => ({
    ...user,
    orders: user.orders,
    // Transform any data if required
    totalSpent: user.orders.reduce((sum, order) => sum + order.total, 0)
  }));
};

2. Amnesty International misses the restrictions of context when integrating with the Bass code

interface User {
  id: string;
  name: string;
  email: string;
}

const getUserDetails = async (userId: string): Promise => {
  const response = await fetch(`/api/users/${userId}`);
  if (!response.ok) throw new Error('Failed to fetch user');
  return await response.json();
};

✅ Better solution: Follow the applicable application patterns

import { ApiService } from '@/services/api';
import { User } from '@/types/user';
import { handleApiError } from '@/utils/error-handling';

export const getUserDetails = async (userId: string): Promise => {
  try {
    return await ApiService.get(`users/${userId}`);
  } catch (error) {
    return handleApiError(error, 'Failed to fetch user details');
  }
};

3. Amnesty International provides reasonable assumptions, but it misses the requirements for the field

❌ Amnesty International’s proposal: Technically correct discount account

const calculateDiscount = (price: number, discountPercent: number): number => {
  const discountAmount = price * (discountPercent / 100);
  return price - discountAmount;
};

✅ Better solution: merges the rules of work and coordination

const calculateDiscount = (price: number, discountPercent: number): number => {
  // Company policy: Maximum discount is 40% unless approved
  const effectiveDiscount = Math.min(discountPercent, 40);
  
  // Business rule: Discounts are calculated after tax in our system
  const priceWithTax = addTax(price);
  
  const discountAmount = priceWithTax * (effectiveDiscount / 100);
  
  // Format to company standard: always round to nearest cent
  return Number((priceWithTax - discountAmount).toFixed(2));
};

🚀 The truth? AI don’t write a bad symbol – your mind can only be read

The pattern is clear: AI surpasses the generation of the correct sound code, algorithm. What is constantly missing:

1. The context of work and field rules – You cannot know your company’s specific policies
2. Project conferences – It has a limited understanding of your blade base patterns
3. Architectural effects – It focuses on the function on hand, not the system as a whole
4. Wide performance Important improvements in production environments

1. Boilerplate’s artificial intelligence reservation, but carefully reviewing integration points Artificial intelligence excels in generating frequent patterns, but often misses how components are connected to larger systems.

2. Master claims with the context –

• 🚫 “Create a TypeSCRIPT reaction to bring data”
• ✅ “Create a TypeScript reaction hook to bring in data that follows our current error processing style, and includes cleaning on Unmount, and deals with meaningless requests.”

3. Check out the edge cases that artificial intelligence may miss.

describe('calculateDiscount', () => {
  it('correctly calculates a 20% discount on $100', () => {
    expect(calculateDiscount(100, 20)).toBe(80);
  });
  it('handles zero price', () => {
    expect(calculateDiscount(0, 15)).toBe(0);
  });
  it('handles zero discount', () => {
    expect(calculateDiscount(50, 0)).toBe(50);
  });
  it('handles decimal precision correctly', () => {
    expect(calculateDiscount(9.99, 10)).toBe(8.99);
  });
  it('rejects negative prices', () => {
    expect(() => calculateDiscount(-10, 20)).toThrow();
  });
  it('rejects invalid discount percentages', () => {
    expect(() => calculateDiscount(100, 101)).toThrow();
    expect(() => calculateDiscount(100, -5)).toThrow();
  });
});

These are not “errors” in the traditional sense, but they are basic restrictions: AI cannot understand your field of business, company standards, or the complete context of your application engineering in the way that an experienced team member can do.

🚀 The bottom line? AI is a powerful tool, but it’s not your CTO. Think critically. A strong review. Smart symbol.

📢 “The Engineer Register” is the place where we rule the world of AI and Web3 and software engineering – without BS. Subscribe to deep diving, best coding practices, and error correction stories in the real world.

🛠 Join the newsletter → Record