1. 실험 개요: AI가 코드를 짜는 시대, 개발자의 미래는?

최근 저코드/노코드 플랫폼과 AI 코딩 도구의 열풍 속에서 "개발자 종말론"이 끊임없이 제기되고 있다. 마치 비전문가도 자연어로 애플리케이션을 만들 수 있고, AI가 요구사항만으로 완벽한 코드를 뽑아내는 세상이 코앞에 다가온 듯한 분위기다. 10년 넘게 코드를 작성해온 개발자로서, 이러한 낙관론에 의문을 제기하고자 본격적인 비교 실험을 설계했다.

실험 대상은 현재 가장 주목받는 세 가지 방식이다: OpenAI의 ChatGPT와 Codex, 그리고 Microsoft의 GitHub Copilot. 이들과 전통적인 수동 구현 방식을 세 가지 핵심 알고리즘에서 정면으로 비교했다. 선택한 알고리즘은 배열 교집합(Intersection), 카르테시안 곱(Cartesian Product), 함수 메모이제이션(Memoization)이다. 데이터 중심 시대에 대용량 처리 효율이 핵심인 만큼, 이 기초 알고리즘들의 구현 품질이 곧 시스템 성능을 좌우한다.

실험 방법은 명확하다. 동일한 기능 명세로 각 AI에게 JavaScript 함수 생성을 요청하고, Jasmine 단위 테스트와 커스텀 성능 측정 도구로 정확성, 실행 속도, 리소스 소비량을 검증한다. 마지막으로 NPM에 등록된 검증된 고성능 라이브러리와 비교하며, 코드 리뷰 관점에서 AI 산출물의 강점과 약점을 분석한다.

2. 실험 환경과 평가 기준: 공정한 비교를 위한 방법론

2.1 측정 도구와 지표

단위 검증에는 Jasmine을 활용해 기능적 정확성을 확인했다. 성능 평가에서는 Benchmark.js 스타일의 커스텀 러너를 구축하여 다음 지표를 추적했다:

• 초당 연산 수(Ops/Sec): 처리량, 높을수록 우수
• 힙 메모리 사용량(Heap Used): 바이트 단위, 공간 복잡도를 직접 반영
• 사용자 CPU 시간(User CPU)과 시스템 CPU 시간(System CPU): 마이크로초(µs) 단위의 리소스 효율성

모든 테스트는 Node.js v18.x 환경에서 JIT 워밍업 후 100회 샘플링하여 통계적 유의성을 확보했다. 테스트 데이터는 일반 케이스와 경계 케이스(빈 배열, 중복 요소, 대용량 배열)를 모두 포함하도록 설계했다.

2.2 AI 프롬프팅 전략

각 도구의 특성에 맞춰 동일한 명세를 다르게 전달했다:

• ChatGPT: 대화형 인터페이스로 직접 질문 — "Show me a JavaScript function that takes a variable number of arrays and returns their intersection."
• Codex: Playground 에디터에서 코드 완성 형태로 입력
• Copilot: WebStorm IDE에서 주석으로 명세 작성 후 자동 완성 대기 — // Show me a JavaScript function...

이 방식은 실제 개발 워크플로우를 그대로 재현한다. ChatGPT는 상담가처럼, Codex는 완성 엔진처럼, Copilot은 페어 프로그래밍 동료처럼 작동한다.

2.3 다차원 평가 체계

성능 숫자만 보지 않고 다음 기준으로 종합 판단했다:

1. 기능적 정확성: 모든 단위 테스트 통과 여부
2. 견고성: 경계 조건 처리, 명확한 에러 메시지
3. 성능 특성: 시간/공간 복잡도의 실제 구현 수준
4. 코드 품질: 현대적 문법 활용, 가독성, 유지보수 용이성
5. 의도 파악력: 모호한 요구에 대한 합리적 추론 또는 질문 능력

3. 라운드 1: 배열 교집합(Intersection) 알고리즘 분석

3.1 AI의 초안 제출

ChatGPT의 구현:

function findCommonElements(...arrays) {
  if (arrays.length < 2) {
    throw new Error("At least 2 arrays are required!");
  }
  let accumulator = new Set(arrays.shift());
  for (const current of arrays) {
    accumulator = new Set([...accumulator].filter(x => current.includes(x)));
  }
  return Array.from(accumulator);
}

현대적 문법(... 전개 구문, Set)을 사용하고 구조가 깔끔하다. 하지만 current.includes(x)가 O(n) 선형 탐색이며, 매 반복마다 Set을 배열로 전개하고 다시 Set으로 변환하는 과정에서 중간 배열이 대량 생성된다. 대용량 데이터에서 심각한 병목이다.

Copilot의 구현:

const findCommonElements = (...arrays) => {
  const [head, ...tail] = arrays;
  return head.filter(x => tail.every(arr => arr.includes(x)));
};

극도로 간결한 함수형 스타일이지만 치명적 결함이 있다. 첫 배열의 중복 요소를 제거하지 않아 결과에 중복이 남을 수 있고, every와 includes의 중첩으로 O(n²) 시간 복잡도가 발생한다. 최적화를 위한 전처리(정렬, Set 변환)나 "가장 짧은 배열 우선" 같은 전략도 없다.

Codex의 구현:

function findCommonElements(arrays) {
  var output = [];
  var params = Array.prototype.slice.call(arguments);
  var sources = params.slice(0, params.length - 1);
  var callback = params[params.length - 1];
  var minLen = Math.min.apply(null, sources.map(function(src) {
    return src.length;
  }));
  for (var idx = 0; idx < minLen; idx++) {
    var candidate = sources[0][idx];
    var existsEverywhere = sources.every(function(src) {
      return src.indexOf(candidate) !== -1;
    });
    if (existsEverywhere) {
      output.push(candidate);
    }
  }
  return callback(output);
}

구식 문법(var, Array.prototype.slice.call)과 어색한 인터페이스(마지막 인자로 콜백 함수 요구)가 특징이다. 다만 가장 짧은 배열 길이만 순회하는 점은 알고리즘적 인사이트가 있다. 그러나 내부의 every와 indexOf 중첩로 여전히 비효율적이다.

3.2 "효율성" 요구에 대한 반응

"Show me an efficient..."라고 명시하자 ChatGPT는 다음과 같이 수정했다:

function findCommonElements(...arrays) {
  if (arrays.length < 2) throw new Error("...");
  const result = new Set();
  for (const item of arrays[0]) {
    let isCommon = true;
    for (let i = 1; i < arrays.length; i++) {
      if (!arrays[i].includes(item)) {
        isCommon = false;
        break;
      }
    }
    if (isCommon) result.add(item);
  }
  return Array.from(result);
}

체이닝 대신 명시적 루프로 바꿨지만 includes 여전히 O(n)이라 알고리즘 복잡도는 변함없다. Copilot은 "efficient"라는 정성적 요구를 무시하고 초안과 동일한 코드를 재출력했다. 이는 Copilot의 한계를 보여준다: 구체적인 구현 힌트 없이는 고수준 의도를 해석하기 어렵다.

3.3 객체 지원 요구: 함정에 빠진 AI

객체를 포함한 배열 지원을 요청하자 ChatGPT는 JSON.stringify 기반 비교를 제안했다:

if (!arrays[i].find(x => JSON.stringify(x) === JSON.stringify(item)))

이 방식에는 치명적 문제가 있다. 속성 순서가 다른 동등 객체({a:1,b:2} vs {b:2,a:1})를 다르게 취급하고, 내용이 같아도 별개 엔티티로 봐야 하는 경우에도 강제로 동일시한다. 무엇보다 JSON.stringify는 고비용 연산인데 중첩 루프에서 실행되면 성능이 급락한다.

3.4 성능 대결: AI vs. 수동 최적화

구현 출처	원본 중복 처리	힙 메모리(바이트)	Ops/Sec	사용자 CPU(µs)
ChatGPT	✓	39,768	6.65	152,170
Codex	✓	5,475,888	16.00	69,070
Copilot	✗	30,768	4.16	345,190
intersector (NPM)	✓	37,304	73.02	21,020
fast-array-intersect (NPM)	✓	42,064	20.33	18,990

수동 최적화 라이브러리 intersector는 ChatGPT보다 11배, Copilot보다 17.5배 빠르다. Copilot은 메모리는 적게 쓰지만 속도가 최악이고 기능도 불완전하다. Codex는 속도가 나쁘지 않으나 메모리를 과다 소비한다.

4. 라운드 2: 카르테시안 곱(Cartesian Product)의 미로

4.1 의미적 모호성: AI의 오해

명세 "Show me a JavaScript function for cross product"는 모호하다. 수학에서 "cross product"는 벡터 외적을 의미하기도 한다.

ChatGPT는 벡터 외적을 구현했다:

function vectorCross(v1, v2) {
  var x = v1.y * v2.z - v1.z * v2.y;
  var y = v1.z * v2.x - v1.x * v2.z;
  var z = v1.x * v2.y - v1.y * v2.x;
  return {x: x, y: y, z: z};
}

훈련 데이터에서 통계적으로 우세한 의미를 선택한 결과다.

Copilot은 조합 생성을 시도했으나 오류:

const cartesian = (...arrays) => {
  const [first, ...rest] = arrays;
  return first.flatMap(x => rest.map(y => [x, y]));
};

두 배열일 때는 동작하지만 세 개 이상에서는 첫 배열과 나머지 각각의 카르테시안 곱만 반환해 전체 조합을 놓친다. [1], [2], [3] 입력에 [[1,2], [1,3]]를 출력하는 심각한 기능 결함이다.

4.2 탐욕적 알고리즘의 메모리 함정

여러 시도 후 ChatGPT에서 전체 조합을 생성하는 코드를 얻었으나 모두 탐욕적(greedy) 방식이었다. 수백만 개 조합을 한꺼번에 메모리에 할당하면 OOM(Out of Memory)이 발생한다.

지연 평가(lazy evaluation)를 요구한 결과:

function* lazyCartesian(...sets) {
  const recurse = (arrays, depth = 0) => {
    if (depth === arrays.length - 1) {
      yield* arrays[depth]; // 문법 오류: 일반 함수 내부에서 yield 불가
    } else {
      for (const item of arrays[depth]) {
        for (const suffix of recurse(arrays, depth + 1)) {
          yield [item, ...suffix];
        }
      }
    }
  };
  yield* recurse(sets);
}

중첩 화살표 함수 recurse 내부에서 yield를 사용해 문법 오류가 발생한다. 생성자 함수의 제어 흐름과 스코프 규칙에 대한 이해가 부족한 것이다. Copilot은 "memory efficient"와 "generator" 요구를 무시하고 초기 오류 코드를 반복했다.

4.3 성능 비교: 지연 평가의 압도적 우위

구현 출처	생성 조합 수(목표 10,000)	힙 메모리	Ops/Sec
ChatGPT (오류 버전들)	50~1,000	N/A	N/A
Codex	4	N/A	N/A
Copilot	30	N/A	N/A
커뮤니티 원라이너	10,000	0*	78.46
cxproduct (지연 라이브러리)	10,000	0	291.50
lazy-product (지연 라이브러리)	10,000	17,824	266.65

*메모리 0은 측정 시점 미스매치일 수 있으나, 지연 라이브러리들이 메모리 효율성에서 압도적이다. 이들은 이론적으로 무한대 조합도 처리 가능하다.

5. 라운드 3: 함수 메모이제이션(Memoization) 비교

5.1 AI의 "표준" 구현과 내재적 결함

ChatGPT의 초안(WeakMap 오용):

function memoize(fn) {
  let cache = new WeakMap(); // 키는 객체여야 함
  return function(obj, ...args) {
    let key = JSON.stringify([obj, ...args]); // 문자열 키 생성
    // ... cache.has(key)로 조회 — WeakMap에 문자열 키 사용 불가
  };
}

WeakMap은 객체 키만 허용하는데 문자열 키로 조회하려 해 논리적 모순이다. 일반 Map으로 수정이 필요하다.

Codex와 Copilot의 공통 패턴:

// Codex
function memoize(func) {
  var store = {};
  return function() {
    var args = Array.prototype.slice.call(arguments);
    var key = JSON.stringify(args);
    if (store[key]) return store[key];
    var val = func.apply(null, args);
    store[key] = val;
    return val;
  };
}

// Copilot
const memoize = (fn, store = new Map()) => {
  return (...args) => {
    const key = JSON.stringify(args);
    if (store.has(key)) return store.get(key);
    const result = fn(...args);
    store.set(key, result);
    return result;
  };
};

둘 다 JSON.stringify 기반 키 생성에 의존한다. 이는:

• 직렬화 자체가 고비용 연산으로 메모이제이션 이득을 상쇄할 수 있다
• undefined, Function, Symbol, 순환 참조 객체 등을 제대로 처리하지 못한다
• 속성 순서가 다른 동등 객체를 다른 키로 취급해 캐시 효율이 떨어진다

5.2 전문 라이브러리와의 성능 격차

피보나치(12번째, 재귀) 계산을 테스트했다:

구현 출처	힙 메모리(바이트)	Ops/Sec	사용자 CPU(µs)
ChatGPT (수정 후)	102,552	45,801	620
Codex	17,888	52,238	320
Copilot	17,888	51,301	320
nano-memoize	17,576	93,699	470
micro-memoize	18,872	82,833	620

전문 라이브러리들은 원시값에 === 비교, 객체에 WeakMap 활용 등 정교한 키 전략으로 AI 구현 대비 2배 가까운 성능을 낸다.

6. 종합 분석과 실무 적용 방안

6.1 AI 코드의 체계적 한계

세 라운드를 통해 드러난 공통 패턴:

1. 성능 평균화: 훈련 데이터의 "가장 흔한" 구현을 재생산하며, O(n²)을 O(n)으로 개선하는 알고리즘적 최적화는 자동으로 수행하지 못한다
2. 견고성 결여: 경계 조건, 예외값, 의미적 모호성(객체 동등성) 처리에 실패한다
3. 의미 해석 오류: 모호한 용어("cross product")에 대해 확률적 선택을 하며 명확화 질문을 하지 않는다
4. 품질 편차: 구식 문법, 문법 오류, 기능 오류가 무작위로 발생한다

6.2 개발자를 위한 실용 전략

AI 도구를 효과적으로 활용하려면:

• 보조 도구로 포지셔닝: API 탐색, 보일러플레이트 생성, 단순 유틸리티 작성에 활용하되, 핵심 알고리즘은 신중하게 검증한다
• 극도로 명시적인 명세: "정렬 함수"가 아니라 "퀵소트, 제자리 정렬, 숫자 배열, 빈 배열 처리"까지 상세히 서술한다
• 강제적 코드 리뷰: AI 출력물을 주니어 개발자의 PR처럼 대하고 테스트, 프로파일링, 보안 검토를 거친다
• 반복적 정제 활용: 오류 피드백을 통해 원하는 형태로 다듬는 과정을 인정하고 활용한다

6.3 AI 도구의 진화 방향

전문가 수준에 도달하기 위한 필요 혁신:

1. 자기 분석 능력: 생성 후 정적 분석, 단위 테스트 실행, 성능 프로파일링을 자동으로 수행하고 개선을 반복한다
2. 논리적 추론: 확률적 패턴 매칭을 넘어 알고리즘 복잡도, 언어 의미론, 문제 제약 조건을 깊이 이해한다
3. 대화적 명세 정제: 모호한 요구에 대해 "벡터 외적인가 조합 생성인가?", "속도와 메모리 우선순위는?" 같이 질문한다
4. 품질 가중 학습: 검증된 최적实践 코드와 반례 분석 데이터를 높은 가중치로 학습한다

AI가 개발자를 대체하는가? 현재로서는 아니다. AI는 "AI를 활용하는 개발자"와 "그렇지 않은 개발자"를 가르는 기준이 될 것이다. 복잡한 비즈니스 로직 이해, 고성능 아키텍처 설계, 엄격한 코드 리뷰, 모호한 문제 해결에 집중하는 개발자의 가치는 AI의 기초 작업 보조로 더욱 부각될 것이다. 이 경쟁은 "AI 대 개발자"가 아니라 "AI와 함께하는 개발자 대 그렇지 않은 개발자"의 구도다.