2010년대 실리콘밸리 채용 공고:

"우리는 10x 엔지니어를 찾습니다"
= 1명 월급으로 10명분 일 시키겠다는 뜻

"락스타 개발자를 구합니다"
= 새벽 3시까지 일할 사람 구한다는 뜻

"닌자 프로그래머 환영"
= 아무도 모르게 배포하고 사라질 사람 구한다는 뜻

// 0.1x 엔지니어: 버튼 색깔을 3일 동안 고민함
const buttonColor = useMemo(() => {
  const hue = calculateOptimalHue(userPreferences);
  const saturation = adjustForAccessibility(hue);
  const lightness = computeContrastRatio(saturation, backgroundColor);
  return `hsl(${hue}, ${saturation}%, ${lightness}%)`;
}, [userPreferences, backgroundColor]);

// 10x 엔지니어: 디자이너한테 물어봄
const buttonColor = theme.colors.primary;

// 0.1x 엔지니어의 디버깅 과정
// 1. console.log 200개 추가
console.log("여기1");
console.log("여기2");
console.log("여기 들어옴?");
console.log("여기는?");
console.log("왜 안됨");
console.log("아 진짜 왜");
console.log("됐나?");
console.log("안됐네");
// 2. 랜덤으로 코드 수정
// 3. 되면 커밋 (왜 되는지 모름)
// 4. 3개월 후 다시 터짐

// 10x 엔지니어의 디버깅 과정
// 1. 에러 메시지를 실제로 읽음 (혁명적)
// 2. 스택 트레이스를 따라감
// 3. 가설을 세움
// 4. 가설을 검증함
// 5. 근본 원인을 수정함
// 6. 재발 방지 테스트를 추가함

// 0.1x 엔지니어의 코드 리뷰
// PR 올림 → LGTM 받음 → 머지 → 끝

// 실제 0.1x의 PR 설명:
// Title: "fix stuff"
// Description: ""
// Files changed: 47
// Reviewers: 없음 (셀프 머지)

// 10x 엔지니어의 코드 리뷰
// PR 올리기 전:
// - 스스로 한번 리뷰함
// - 테스트 확인
// - PR 설명에 WHY를 적음

// Title: "fix: prevent race condition in payment processing"
// Description:
// ## Problem
// 동시 결제 요청 시 재고가 음수가 되는 버그 발견
//
// ## Root Cause
// checkInventory()와 deductInventory() 사이에 락이 없음
//
// ## Solution
// Redis 분산 락 적용 + 재고 확인-차감 원자적 처리
//
// ## Test Plan
// - 동시 100건 결제 요청 시뮬레이션 통과
// - 기존 결제 플로우 E2E 테스트 통과

// 0.1x 엔지니어의 에러 처리 철학
// "에러가 안 보이면 에러가 아니다"

async function processPayment(order: Order) {
  try {
    const result = await paymentGateway.charge(order);
    return result;
  } catch (error) {
    // 에러 삼킴. 조용히. 우아하게.
    console.log("뭔가 에러남");
    return null; // null을 반환해서 다음 사람이 NPE로 고생하게 만듦
  }
}

// 3개월 후 CS팀: "결제 됐다는데 주문이 안 들어와요"
// 0.1x: "제 코드엔 에러 없는데요?"
// 기술적으로 맞는 말이긴 함. 에러를 삼켜버렸으니까.

// 0.1x 엔지니어의 DRY 원칙: Don't Repeat... 아 몰라 복붙해

// user-service.ts
async function getUser(id: string) {
  const connection = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'password123',
    database: 'myapp'
  });
  const [rows] = await connection.execute('SELECT * FROM users WHERE id = ?', [id]);
  await connection.end();
  return rows[0];
}

// order-service.ts  (똑같은 연결 코드 복붙)
async function getOrder(id: string) {
  const connection = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'password123',  // 하드코딩된 비밀번호가 10개 파일에 복붙됨
    database: 'myapp'
  });
  const [rows] = await connection.execute('SELECT * FROM orders WHERE id = ?', [id]);
  await connection.end();
  return rows[0];
}

// product-service.ts  (또 복붙)
// payment-service.ts  (또또 복붙)
// notification-service.ts  (또또또 복붙)

// DB 비밀번호 변경 시: 10개 파일 다 찾아서 바꿔야 함
// 0.1x: "grep으로 찾으면 되잖아요"
// 그 grep에서 하나 빠뜨려서 프로덕션 장애 남

// 0.1x 엔지니어의 테스트 전략

// 전략 1: 테스트를 작성하되 아무것도 테스트하지 않음
describe('UserService', () => {
  it('should work', () => {
    expect(true).toBe(true); // 항상 통과하는 테스트
  });

  it('should handle edge cases', () => {
    // TODO: 나중에 추가
  });
});

// 전략 2: 스냅샷 테스트로 모든 걸 해결하려고 함
it('should render correctly', () => {
  const tree = renderer.create(<App />).toJSON();
  expect(tree).toMatchSnapshot();
  // 뭐가 바뀌든 `--updateSnapshot` 치면 됨
  // "테스트 통과시켰습니다" 라고 당당히 말함
});

// 전략 3: 테스트 파일만 만들고 안에 아무것도 없음
// __tests__/payment.test.ts
// (빈 파일)
// "테스트 파일 구조는 잡아놨습니다"

// 0.1x 엔지니어 버전
async function getActiveUsers() {
  let users: any[] = []; // any 남발
  try {
    const response = await fetch('/api/users');
    const data = await response.json();
    users = data;
  } catch (e) {
    // 에러? 무시ㅋ
  }

  let activeUsers: any[] = [];
  for (let i = 0; i < users.length; i++) {
    if (users[i].status == 'active') { // == 사용 (=== 아님)
      activeUsers.push(users[i]);
    }
  }

  // 버블 소트로 정렬 (왜?)
  for (let i = 0; i < activeUsers.length; i++) {
    for (let j = 0; j < activeUsers.length - 1; j++) {
      if (activeUsers[j].name > activeUsers[j + 1].name) {
        let temp = activeUsers[j];
        activeUsers[j] = activeUsers[j + 1];
        activeUsers[j + 1] = temp;
      }
    }
  }

  return activeUsers;
}

// 10x 엔지니어 버전
interface User {
  id: string;
  name: string;
  status: 'active' | 'inactive' | 'suspended';
  email: string;
}

async function getActiveUsers(): Promise<User[]> {
  const response = await fetch('/api/users');

  if (!response.ok) {
    throw new ApiError(`Failed to fetch users: ${response.status}`, {
      status: response.status,
      endpoint: '/api/users',
    });
  }

  const users: User[] = await response.json();

  return users
    .filter((user) => user.status === 'active')
    .sort((a, b) => a.name.localeCompare(b.name, 'ko'));
}

// 10x 엔지니어가 만든 공통 유틸리티
// → 팀 전체가 2시간씩 절약

// 공통 API 클라이언트
class ApiClient {
  private baseUrl: string;
  private defaultHeaders: Record<string, string>;

  constructor(config: ApiClientConfig) {
    this.baseUrl = config.baseUrl;
    this.defaultHeaders = {
      'Content-Type': 'application/json',
      ...config.headers,
    };
  }

  async request<T>(endpoint: string, options?: RequestOptions): Promise<T> {
    const url = `${this.baseUrl}${endpoint}`;
    const response = await fetch(url, {
      ...options,
      headers: { ...this.defaultHeaders, ...options?.headers },
    });

    if (!response.ok) {
      throw new ApiError(
        `API request failed: ${response.status} ${response.statusText}`,
        { status: response.status, endpoint, url }
      );
    }

    return response.json();
  }

  // 편의 메서드들
  get<T>(endpoint: string) { return this.request<T>(endpoint, { method: 'GET' }); }
  post<T>(endpoint: string, body: unknown) {
    return this.request<T>(endpoint, {
      method: 'POST',
      body: JSON.stringify(body),
    });
  }
}

// 팀원들: "이거 쓰니까 API 연동이 10분이면 끝나요"
// → 이게 진짜 10x. 본인이 10배가 아니라 팀 전체를 10배로 만드는 것.

// 0.1x 엔지니어가 머지한 코드 때문에
// 다른 팀원 3명이 각각 반나절씩 디버깅함

// 0.1x가 짠 "유틸리티"
function doStuff(data: any, flag: boolean, type: string, extra?: any) {
  if (flag) {
    if (type === 'A') {
      // 200줄의 스파게티
    } else if (type === 'B') {
      // 또 200줄의 스파게티
    } else if (type === 'C') {
      // flag가 true이고 type이 C인 경우는 실제로 없지만
      // "나중에 쓸 수도 있으니까" 만들어 놓음
    }
  } else {
    // flag가 false인 경우
    if (extra) {
      // extra가 있으면... 근데 extra의 타입이 any라서
      // 뭐가 들어오는지 아무도 모름
    }
  }
}

// 6개월 후 이 함수를 수정해야 하는 사람:
// "이게 뭐하는 함수인지 모르겠는데요..."
// "doStuff가 뭔 stuff를 do하는 건데..."
// → 결국 새로 짬. 0.1x가 쓴 시간 + 다시 짜는 시간 = 마이너스 생산성

생산성 스펙트럼:

0.1x --------- 0.5x --------- 1x --------- 3x --------- 10x
  │              │              │             │              │
  │              │              │             │              │
  마이너스     배우는 중      평균          꽤 잘함        전설
  생산성       성장 중        기여          팀 레버리지    (거의 없음)

대부분의 개발자는 여기 어딘가에 있음: [====0.7x ~ 2x====]
그리고 그건 완전히 정상임.

// Step 1: 에러를 삼키지 않기
// Before
try { doSomething(); } catch (e) { }

// After
try {
  doSomething();
} catch (error) {
  logger.error('Failed to do something', { error, context: relevantInfo });
  throw error; // 또는 의미 있는 대체 동작
}

// Step 2: any를 쓰지 않기
// Before
function processData(data: any): any { ... }

// After
function processData(data: UserInput): ProcessedResult { ... }

// Step 3: 코드 리뷰 코멘트를 진짜로 반영하기
// Before: "네 수정할게요" → resolve 클릭 → 수정 안 함

// After: 진짜 수정함. 이해 안 되면 물어봄.
// "이 부분 왜 이렇게 바꿔야 하는지 설명해주실 수 있나요?"
// → 이게 학습이고, 이게 성장임.

10x 엔지니어가 필요한 이유:
- 채용을 잘못해서 (→ 채용 프로세스 개선이 답)
- 프로세스가 엉망이라서 (→ 프로세스 개선이 답)
- 기술 부채가 너무 쌓여서 (→ 꾸준한 리팩토링이 답)
- 사람이 부족해서 (→ 추가 채용이 답)

"10x 엔지니어 한 명 뽑으면 해결됨"은
"로또 당첨되면 해결됨"과 같은 수준의 전략임.