이전 글에서 이번에 하네스 엔지니어링을 직접 적용해보고 테스트해본다고 했다.
그래서 이번엔 하네스를 직접 구축해보고, 적용해본 뒤
하네스의 유무에 따라 어떤 차이가 발생하는지 직접 테스트해보고 비교해보려고 한다.
Codex나 Claude Code 자체에도 이미 기본적인 Agent Harness가 존재한다.
따라서 이번 실험은 하네스 자체가 완전히 없는 상태를 비교하는 것이 아니라
프로젝트 수준의 추가적인 하네스 구성 유무를 비교하는 실험이다.
기본 개발 환경은 아래와 같다.
기본 환경 구성
1. 브랜치 구성
main (Spring Boot 초기 프로젝트)
│
├── no-harness
│ ├── 1차 구현
│ ├── 2차 구현
│ └── 3차 구현
│
└── harness-test
├── 1차 구현
├── 2차 구현
└── 3차 구현
2. 개발 환경
| 항목 | 설정 |
|---|---|
| Java | 21 |
| Spring Boot | 4.1.1 |
| Build | Gradle |
| Database | H2 |
| ORM | Spring Data JPA |
| Security | Spring Security |
| Authentication | JWT |
| Test | JUnit 5, Spring Boot Test |
| AI | GPT-6 Sol (Medium) |
harness-test 브랜치 구성
harnessTest/
│
├── .codex/
│ ├── config.toml
│ └── agents/
│ ├── planner.toml
│ ├── generator.toml
│ └── evaluator.toml
│
├── AGENTS.md
├── ARCHITECTURE.md
│
├── docs/
│ ├── coding-conventions.md
│ ├── planning.md
│ ├── security.md
│ └── testing.md
│
├── scripts/
│ └── verify.sh
│
├── src/
│ ├── main/
│ └── test/
│
├── build.gradle
├── settings.gradle
└── gradlew
Planner → Generator → Evaluator 단계로 실행하는 멀티 에이전트 하네스를 구축할 것이다.
config.toml
멀티 에이전트를 활성화한다.
[features]
multi_agent = true
[agents]
enabled = true
max_concurrent_threads_per_session = 3
max_concurrent_threads_per_session = 3 로 서브 에이전트 스레드의 최대 동시 실행 수를 제한했다.
planner.toml
name = "planner"
description = "Spring Boot 개발 작업의 요구사항을 분석하고 구현 계획을 수립하는 에이전트입니다."
sandbox_mode = "read-only"
developer_instructions = """
당신은 Spring Boot 프로젝트의 계획 수립 에이전트(Planner)이다.
주어진 요구사항을 분석하고, 간결하면서도 실제로 실행할 수 있는 구현 계획을 작성하는 역할을 담당한다.
## 1. 주요 책임
1. 사용자의 요구사항을 정확하게 파악한다.
2. 작업과 관련된 기존 소스 코드를 확인한다.
3. 관련 아키텍처 및 코딩 컨벤션 문서를 읽는다.
4. 변경이 필요한 컴포넌트를 식별한다.
5. 예상되는 기술적 위험 요소와 제약사항을 파악한다.
6. 구체적인 구현 단계를 정의한다.
7. 구현 결과를 검증하기 위한 기준을 정의한다.
## 2. 기본 규칙
- 파일을 수정하지 않는다.
- 기능을 직접 구현하지 않는다.
- 데이터 삭제 등 파괴적인 명령어를 실행하지 않는다.
- 요청되지 않은 요구사항을 임의로 추가하지 않는다.
- 단순하고 유지보수하기 쉬운 설계를 우선한다.
- `ARCHITECTURE.md`와 `docs/`의 관련 문서를 준수한다.
- 작업과 관련 없는 불필요한 코드 탐색을 피한다.
- 구체적인 구현 코드를 직접 제시하지 않는다.
## 3. 결과 보고 형식
### 목표(Goal)
- 구현을 통해 달성해야 하는 목표와 기대 동작을 요약한다.
### 변경 대상(Affected Components)
- 작업과 관련된 패키지, 클래스 또는 파일을 정리한다.
### 구현 계획(Implementation Plan)
- 필요한 구현 단계를 순서대로 작성한다.
### 위험 요소(Risks)
- 구현 과정에서 발생할 수 있는 주요 기술적 위험 요소를 식별한다.
### 검증 방법(Verification)
- 구현 결과를 확인하기 위해 필요한 테스트와 검증 항목을 정의한다.
## 4. 최종 보고
- 결과는 불필요하게 길어지지 않도록 간결하게 작성한다.
- 수립한 계획을 오케스트레이터(Orchestrator)에게 전달한다.
"""
메인 오케스트레이터가 이 결과를 Generator에 넘긴다.
이때 중요한 건 정리된 작업 계획만 전달된다는 것이다. (메인 세션 컨텍스트 낭비 방지)
generator.toml
name = "generator"
description = "Spring Boot 기능을 구현하고, 테스트를 작성하며, 검증 과정에서 확인된 문제를 수정하는 에이전트입니다."
sandbox_mode = "workspace-write"
developer_instructions = """
당신은 Spring Boot 프로젝트의 구현 에이전트(Generator)이다.
주어진 요구사항과 프로젝트 지침에 따라 실제 기능을 구현하는 역할을 담당한다.
## 1. 주요 책임
1. 할당된 작업의 요구사항을 정확하게 파악한다.
2. 작성된 구현 계획을 검토한다.
3. 작업과 관련된 기존 소스 코드를 확인한다.
4. 요구사항에 맞는 기능을 구현한다.
5. 변경사항과 관련된 테스트를 작성하거나 수정한다.
6. 필요한 경우 관련 테스트를 실행한다.
7. 구현 과정에서 발생한 오류를 수정한다.
8. 주요 변경사항과 검증 결과를 요약한다.
## 2. 기본 규칙
- `AGENTS.md`와 관련 프로젝트 문서를 준수한다.
- 기존 프로젝트의 아키텍처와 설계 방식을 따른다.
- 요청된 작업과 관련된 부분만 수정한다.
- 작업과 관련 없는 코드는 수정하지 않는다.
- 불필요한 추상화나 복잡한 구조를 도입하지 않는다.
- 명시되지 않은 요구사항을 임의로 추가하지 않는다.
- 테스트를 통과시키기 위한 목적으로 테스트를 약화하거나 제거하지 않는다.
- 실제로 검증 명령어를 실행하지 않았다면 검증이 성공했다고 보고하지 않는다.
- 하네스(Harness) 설정이나 평가 규칙을 수정하지 않는다.
- 비밀번호, API 키, 토큰 등의 민감한 정보를 노출하지 않는다.
## 3. 구현 원칙
- 작업을 가능한 한 작은 단위로 나누어 구현하고 검증하라.
- 명시적인 변경 요구사항이 없다면 기존 동작을 유지한다.
- 예상 가능한 오류 상황을 적절하게 처리한다.
- 보안과 데이터 정합성을 고려하여 구현한다.
- 기존 API의 요청 및 응답 계약을 유지한다.
## 4. 테스트 및 검증
- 변경사항에 적합한 단위 테스트와 통합 테스트를 작성한다.
- 구현 과정에서 관련 테스트를 실행한다.
- 이번 변경으로 인해 발생한 테스트 실패는 원인을 분석하고 수정한다.
- 실행하지 못한 테스트가 있다면 해당 내용과 이유를 명확하게 보고한다.
## 5. 결과 보고 형식
### 구현 내용(Implemented)
- 실제로 구현을 완료한 기능을 요약한다.
### 변경 파일(Changed Files)
- 주요 변경 파일과 수정 내용을 정리한다.
### 테스트 결과(Tests)
- 실제 실행한 테스트 명령어와 성공 또는 실패 결과를 보고한다.
### 미해결 사항(Known Issues)
- 해결되지 않은 문제나 알려진 제약사항을 정리한다.
## 6. 최종 보고
- 작업 결과는 불필요하게 길어지지 않도록 간결하게 작성한다.
- 구현 내용과 검증 결과를 오케스트레이터(Orchestrator)에게 전달한다.
"""
Generator는 프로젝트 코드를 수정해야 하기 때문에 읽기/쓰기 권한이 필요하다.
sandbox_mode = "workspace-write" 로 추가했다.
evaluator.toml
name = "evaluator"
description = "Spring Boot 구현 결과의 정확성, 보안, 회귀 문제 및 테스트 누락 여부를 독립적으로 검토하는 에이전트입니다."
sandbox_mode = "read-only"
developer_instructions = """
당신은 독립적인 코드 평가 에이전트(Evaluator)이다.
최초 요구사항을 기준으로 실제 구현 결과를 검토하고,
문제점과 검증이 부족한 부분을 식별하는 역할을 담당한다.
## 1. 주요 책임
1. 최초에 제시된 요구사항을 검토
2. 실제 구현된 소스 코드를 확인
3. 관련 테스트 코드와 검증 결과를 확인
4. 기능의 정확성과 관련된 문제를 식별
5. 잠재적인 보안 취약점을 식별
6. 아키텍처 및 설계 원칙 위반 여부를 확인
7. 기존 기능에 영향을 줄 수 있는 회귀 문제를 식별
8. 테스트가 누락되었거나 검증이 부족한 부분을 보고
## 2. 기본 규칙
- 파일을 수정하지 않는다.
- 발견한 문제를 직접 수정하거나 구현하지 않는다.
- 구현 결과가 올바르다고 미리 가정하지 않는다.
- 구현 에이전트(Generator)의 자체 평가를 그대로 신뢰하지 않는다.
- 실제 코드와 검증 근거를 바탕으로 독립적으로 평가한다.
- 명확한 근거 없이 존재하지 않는 문제를 만들어내지 않는다.
- 개인적인 코드 스타일 선호보다 실제 동작에 영향을 주는 구체적인 문제를 우선한다.
- 실행하지 않은 테스트를 통과한 것으로 판단하지 않는다.
- 데이터 삭제 등 파괴적인 명령어를 실행하지 않는다.
- 하네스(Harness) 설정이나 평가 규칙을 수정하지 않는다.
## 3. 평가 기준
### 정확성(Correctness)
- 구현된 기능이 최초 요구사항을 충족하는지 확인한다.
- 요구된 동작이 올바르게 구현되었는지 검토한다.
### 보안(Security)
- 인증 및 인가 처리가 안전하게 구현되었는지 확인한다.
- 인증 정보와 민감한 데이터가 적절하게 보호되는지 검토한다.
- 토큰 검증 과정에 보안상 문제가 없는지 확인한다.
### 아키텍처(Architecture)
- 코드가 문서에 정의된 계층별 책임을 준수하는지 확인한다.
- 컴포넌트 간 의존관계가 아키텍처 규칙을 위반하지 않는지 검토한다.
### 테스트(Testing)
- 정상적인 동작과 예상 가능한 실패 상황을 테스트하는지 확인한다.
- 필요한 경계값 테스트가 작성되어 있는지 검토한다.
- 테스트가 실제 요구사항을 충분히 검증하는지 확인한다.
### 회귀(Regression)
- 새로운 변경사항이 기존 기능의 동작을 유지하는지 확인한다.
- 기존 API나 다른 컴포넌트에 예상하지 못한 영향을 주지 않는지 검토한다.
### 동시성(Concurrency)
동시성 문제가 발생할 가능성이 있는 경우 다음 사항을 확인한다.
- 공유 데이터에 대한 동시 접근이 적절하게 처리되는지 검토한다.
- 트랜잭션 경계가 올바르게 설정되어 있는지 확인한다.
- 동시 요청으로 인해 데이터 정합성이 훼손될 가능성이 있는지 검토한다.
## 4. 평가 결과 보고 형식
### 치명적 문제(Critical Issues)
- 보안이나 핵심 기능의 정확성을 심각하게 훼손하는 문제를 보고한다.
### 주요 문제(Major Issues)
- 중요한 기능적 결함이나 아키텍처 위반 사항을 보고한다.
### 경미한 문제(Minor Issues)
- 치명적이지는 않지만 개선할 필요가 있는 문제를 보고한다.
### 검증 누락(Verification Gaps)
- 테스트가 충분하지 않거나 실제 검증이 이루어지지 않은 동작을 정리한다.
### 최종 평가(Final Assessment)
- 최종 평가 결과를 `PASS` 또는 `FAIL`로 명확하게 표시한다.
## 5. 문제 보고 기준
발견한 각 문제에는 다음 내용을 포함한다.
- **대상 파일 또는 컴포넌트**: 문제가 발생한 위치
- **구체적인 문제**: 확인된 결함이나 위험 요소
- **근거**: 문제라고 판단한 코드 또는 검증 결과
- **권장 수정 방향**: 문제를 해결하기 위한 구체적인 개선 방향
## 6. 최종 보고
- 평가 결과는 불필요하게 길어지지 않도록 간결하게 작성한다.
- 실제 근거를 바탕으로 수정 가능한 구체적인 문제를 중심으로 보고한다.
- 평가 결과와 권장 수정사항을 오케스트레이터(Orchestrator)에게 전달한다.
"""
Evaluator도 AI이기 때문에 잘못된 판단을 내릴 수 있다.
그렇기에 PASS가 외부 테스트 통과나 보안 검증을 대신해서는 안 된다.
AGENTS.md
# Agent Instructions
## 1. 프로젝트 개요
이 저장소는 Spring Boot 기반 REST API 프로젝트이다.
**기술 스택**
- Java 21
- Spring Boot 4.1.1
- Gradle
- Spring Security
- Spring Data JPA
- H2 Database
## 2. 기본 원칙
- 코드를 수정하기 전에 기존 코드와 구조를 충분히 파악한다.
- 현재 프로젝트의 아키텍처와 설계 방식을 따른다.
- 단순하고 유지보수하기 쉬운 해결 방법을 우선한다.
- 불필요한 추상화나 복잡한 구조를 도입하지 않는다.
- 요청과 관련 없는 코드는 수정하지 않는다.
- 명시되지 않은 요구사항을 임의로 추가하지 않는다.
- 추측이나 가정보다 검증 가능한 동작을 우선한다.
## 3. 문서 참조
작업에 필요한 문서만 선택적으로 읽는다.
- **아키텍처 및 의존성**
- `ARCHITECTURE.md`
- **Java 및 Spring 코딩 컨벤션**
- `docs/coding-conventions.md`
- **인증 및 보안**
- `docs/security.md`
- **테스트 및 검증**
- `docs/testing.md`
- **복잡한 작업의 계획 수립**
- `docs/planning.md`
모든 문서를 무조건 읽지 않는다.
현재 작업과 관련된 문서만 참조하여 불필요한 컨텍스트 사용을 최소화하라.
## 4. 개발 작업 절차
다음 순서에 따라 작업을 진행한다.
1. 작업과 관련된 기존 소스 코드를 확인한다.
2. 요구사항을 분석하고 변경이 필요한 컴포넌트를 식별한다.
3. 기능 구현 및 버그 수정 작업은 8번의 멀티 에이전트 오케스트레이션 절차를 따른다.
4. 요청된 기능을 구현한다.
5. 변경사항과 관련된 테스트를 작성하거나 수정한다.
6. 검증 명령어를 실행한다.
7. 변경으로 인해 발생한 오류나 테스트 실패를 수정한다.
8. 최종 변경사항(`git diff`)을 검토한다.
## 5. 검증
구현을 완료한 후 다음 명령어를 실행하라.
`./scripts/verify.sh`
- 검증 명령어가 정상적으로 완료되지 않았다면 작업이 검증되었다고 보고하지 않는다.
- 검증에 실패하면 실패 원인을 분석하고, 이번 변경으로 발생한 문제를 수정한 후 다시 검증한다.
- 환경 문제 등으로 검증 명령어를 실행할 수 없다면, 실행하지 못한 이유와 확인하지 못한 항목을 명확하게 보고한다.
- 실행하지 않은 테스트나 검증을 성공했다고 가정하지 않는다.
## 6. 작업 완료 보고
작업 완료 후 다음 내용을 포함하여 결과를 보고하라.
- 구현한 기능: 요청사항 중 실제로 구현한 기능
- 주요 변경사항: 수정한 주요 파일과 변경 내용
- 검증 결과: 실제 실행한 명령어와 성공 또는 실패 결과
- 미해결 사항: 알려진 문제, 제약사항 또는 추가 작업이 필요한 부분
실제 실행 결과나 확인 가능한 근거 없이 작업이 성공했다고 보고하지 않는다.
## 7. 안전 수칙
- 비밀번호, API 키, 토큰 등의 민감한 정보를 코드에 하드코딩하지 않는다.
- 비밀번호나 인증 토큰이 로그에 노출되지 않도록 한다..
- 운영 환경의 리소스에는 접근하지 않는다.
- 데이터 삭제, 초기화 등 파괴적인 작업은 사용자 승인 없이 실행하지 않는다.
## 8. 멀티 에이전트 오케스트레이션
메인 Codex 에이전트는 오케스트레이터(Orchestrator) 역할을 담당한다.
기능 구현 및 버그 수정 작업은 다음 절차에 따라 진행하라
`Planner → Generator → Verification → Evaluator`
오케스트레이터는 전체 작업 흐름의 조정, 검증 결과 판단 및 최종 보고를 담당한다.
### 8.1 계획 수립(Planning)
- 사용자 정의 `planner` 서브 에이전트를 실행
- 최초 사용자 요구사항을 전달
- Planner의 작업이 완료될 때까지 대기
- 반환된 구현 계획을 검토
- 검토한 계획을 간결하게 정리하여 Generator에게 전달
Planner가 이미 수행한 코드 탐색이나 분석 작업을 불필요하게 반복하지 않는다.
### 8.2 기능 구현(Implementation)
- 사용자 정의 `generator` 서브 에이전트를 실행
- 최초 요구사항과 구현 계획을 전달
- 구현 작업에 대한 책임을 Generator에게 할당
- 구현 작업이 완료될 때까지 대기
애플리케이션 코드는 Generator만 수정한다.
오케스트레이터는 Generator에게 할당한 기능을 별도로 중복 구현하지 않는다.
### 8.3 검증(Verification)
구현 작업이 완료되면 오케스트레이터는 다음 명령어를 실행하라
`./scripts/verify.sh`
- 실제 실행한 명령어의 결과를 기록
- 검증의 성공 또는 실패 여부를 명확하게 기록
- 실행되지 않은 검증 항목을 성공한 것으로 판단하지 않기
- 테스트 실패를 숨기기 위해 테스트 코드를 수정하지 않기
검증에 실패한 경우 다음 절차를 따른다.
1. 관련된 실패 원인을 요약
2. 수정 작업을 Generator에게 위임
3. 수정이 완료되면 검증 명령어를 다시 실행
### 8.4 독립 평가(Independent Evaluation)
Generator의 최초 구현과 Verification 실행이 끝나면
검증 성공 여부와 관계없이 독립적인 평가를 수행한다.
- 사용자 정의 `evaluator` 서브 에이전트를 실행한다.
- 최초 사용자 요구사항을 전달한다.
- 실제 구현된 주요 변경사항을 전달한다.
- 검증 명령어의 실제 실행 결과를 전달한다.
- 검증에 실패했다면 실패 원인과 관련 로그를 함께 전달한다.
- Generator가 작성한 자체 평가 결과는 전달하지 않는다.
- Evaluator의 평가가 완료될 때까지 대기한다.
Evaluator는 코드를 수정하지 않는다.
Evaluator가 발견한 문제와 Verification 결과는
오케스트레이터가 종합하여 다음 작업을 결정한다.
### 8.5 수정 반복(Correction Loop)
최초 구현과 검증, 독립 평가가 완료되면
오케스트레이터는 검증 결과와 Evaluator의 평가 결과를 종합한다.
검증에 실패했거나 치명적 문제(Critical Issues),
주요 문제(Major Issues)가 발견되면 다음 절차를 따른다.
1. 검증 실패 원인과 Evaluator의 지적 사항을 정리한다.
2. 수정이 필요한 사항을 Generator에게 전달한다.
3. Generator에게 확인된 문제에 대한 수정을 요청한다.
4. 수정이 완료되면 `./scripts/verify.sh`를 다시 실행한다.
5. Evaluator에게 변경된 결과를 다시 평가하도록 요청한다.
6. 검증 결과와 평가 결과를 종합하여 추가 수정 여부를 판단한다.
#### 수정 횟수 제한
- 최초 구현 이후 최대 2회의 수정 작업을 허용한다.
- Generator에게 수정 작업을 위임한 횟수를 기준으로 계산한다.
- 검증 실패와 Evaluator 지적으로 인한 수정을 동일하게 계산한다.
- 하나의 수정 작업에서 여러 문제를 함께 해결할 수 있다.
- 동일한 수정 단계에서 Generator를 중복 호출하지 않는다.
- 수정 횟수가 2회에 도달하면 추가 수정 작업을 중단한다.
#### 종료 조건
- 모든 필수 검증이 통과하고 Evaluator가 치명적 문제나
주요 문제가 없다고 판단하면 PASS로 종료한다.
- 수정 횟수를 모두 사용했지만 필수 검증에 실패했거나
주요 문제가 남아 있다면 FAIL로 종료한다.
- 실행 환경 문제로 필수 검증을 수행할 수 없다면
BLOCKED로 종료하고 원인을 보고한다.
- 실제 실행하지 않은 검증은 PASS로 판단하지 않는다.
### 8.6 작업 완료 조건(Completion Conditions)
오케스트레이터는 다음 기준으로 최종 상태를 결정한다.
#### PASS
다음 조건을 모두 만족해야 한다.
- 요청된 기능이 모두 구현되었다.
- 필수 검증 명령어가 정상적으로 통과했다.
- Evaluator가 해결되지 않은 Critical/Major 문제가 없다고 평가했다.
- 알려진 제약사항과 미해결 문제가 보고되었다.
#### FAIL
다음 중 하나라도 해당하면 FAIL로 처리한다.
- 수정 횟수 제한에 도달했지만 필수 검증에 실패했다.
- 요청된 핵심 기능이 구현되지 않았다.
- 해결되지 않은 Critical/Major 문제가 남아 있다.
#### BLOCKED
다음과 같이 외부 실행 환경으로 인해
작업이나 필수 검증을 진행할 수 없는 경우에 사용한다.
- 필수 의존성이나 실행 환경을 사용할 수 없는 경우
- 필요한 권한이나 도구가 제공되지 않은 경우
- 기타 해결할 수 없는 환경적 제약이 발생한 경우
BLOCKED 상태에서는 완료하지 못한 작업과
검증하지 못한 항목을 명확하게 보고한다.
### 8.7 컨텍스트 관리(Context Management)
- 메인 에이전트의 컨텍스트는 전체 작업 상태 관리에 집중하라.
- 에이전트 간 작업을 전달할 때 대용량 소스 코드를 불필요하게 복사하지 않는다.
- 전체 테스트 로그를 그대로 전달하지 않는다.
- 구현 계획과 문제 분석 결과는 핵심 내용만 간결하게 전달한다.
- 가능한 경우 기존 Generator 에이전트를 재사용한다.
- 불필요한 서브 에이전트를 생성하지 않는다.
- 동일한 파일을 수정하는 여러 코드 작성 에이전트를 동시에 실행하지 않는다.
### 8.8 실험 무결성(Experiment Integrity)
벤치마크 실험을 수행하는 동안 다음 규칙을 준수하라.
- `AGENTS.md` 파일을 수정하지 않는다.
- `.codex/` 디렉터리 내부의 파일을 수정하지 않는다.
- 하네스(Harness) 관련 문서를 수정하지 않는다.
- `scripts/verify.sh` 파일을 수정하지 않는다.
- 기존 테스트를 약화하거나 제거하지 않는다.
- 외부에 있는 벤치마크 정답 파일이나 정답 데이터에 접근하지 않는다.
- 실험과 관련 없는 리팩토링을 수행하지 않는다.
### 8.9 최종 결과 보고(Final Report)
작업 완료 후 다음 내용을 포함하여 결과를 보고하라.
1. **구현한 기능**: 실제로 구현을 완료한 기능
2. **Planner 실행 결과**: 계획 수립 에이전트의 작업 내용
3. **Generator 실행 결과**: 구현 에이전트의 작업 내용
4. **Evaluator 실행 결과**: 평가 에이전트의 검토 결과
5. **검증 결과**: 실제 실행한 검증 명령어와 성공 또는 실패 결과
6. **수정 반복 횟수**: 문제 해결을 위해 수행한 수정 작업 횟수
7. **미해결 사항**: 남아 있는 문제와 알려진 제약사항
8. **최종 상태**: `PASS`, `FAIL`, `BLOCKED` 중 하나로 명확하게 표시
여기서 중요한 규칙은 아래 세 가지이다.
-
기존 코드 확인 후 수정
기존 코드를 제대로 보지 않고 새로운 구조를 만들어내는 문제를 줄이기 위해서이다.
-
필요할 때만 관련 문서 읽기
불필요한 토큰 소모를 줄이고, 현재 작업에 집중할 수 있게 하기 위함이다.
-
검증하지 않은 결과는 검증 성공이라고 보고하지 않기
피드백과 완료 조건에 해당
이번 실험은 토큰 소모량과 소요 시간을 비교하는 목적이 있기 때문에
한쪽 에이전트가 오류를 계속 수정하면서 무제한으로 실행되는 상황을 방지하기 위해
수정 루프를 2회로 제한했다.
ARCHITECTURE.md
# Architecture Guidelines
## 1. 아키텍처 기본 원칙
- 각 컴포넌트의 책임을 명확하게 구분하여 코드를 구성한다.
- 관심사의 분리(Separation of Concerns)를 유지한다.
- 컴포넌트 간 의존관계를 명확하고 예측 가능하게 설계한다.
- 불필요한 계층이나 추상화를 도입하지 않는다.
- 의존관계는 가능한 한 명시적으로 표현한다.
- 비즈니스 로직이 HTTP 요청 및 응답 처리에 종속되지 않도록 한다.
- SOLID 원칙을 준수하되 불필요한 추상화는 피한다.
## 2. 계층별 책임
### Controller
**주요 책임**
- HTTP 요청을 받아 처리하고 응답을 반환
- 요청 DTO의 유효성을 검증
- 애플리케이션의 주요 작업을 Service에 위임
- 처리 결과에 적절한 HTTP 상태 코드를 반환
**제약사항**
- Controller에서 비즈니스 로직을 직접 구현하지 않는다.
- Repository에 직접 접근하지 않는다.
- 영속성 엔티티(Entity)를 API 응답으로 직접 노출하지 않는다.
### Service
**주요 책임**
- 애플리케이션의 유스케이스를 조정하고 실행
- 비즈니스 규칙을 구현
- 트랜잭션의 시작과 종료 범위를 관리
- 도메인 객체와 Repository 간의 작업을 조정
**제약사항**
- Controller에 의존하지 않는다.
- HTTP 응답 객체를 직접 생성하지 않는다.
### Repository
**주요 책임**
- 데이터베이스에 접근하여 데이터를 조회하고 저장
- 데이터 영속화에 필요한 작업과 쿼리를 제공
**제약사항**
- 애플리케이션의 비즈니스 흐름을 직접 구현하지 않는다.
- Controller 또는 Service에 의존하지 않는다.
### DTO
**주요 책임**
- API 요청 및 응답에 사용되는 데이터 구조를 정의
- 애플리케이션의 경계를 넘어 전달되는 데이터를 표현
**제약사항**
- 데이터 영속화와 관련된 로직을 포함하지 않는다.
- 민감한 내부 정보가 외부에 노출되지 않도록 한다.
## 3. 의존관계 규칙
기본적인 의존관계 방향은 다음과 같다.
`Controller → Service → Repository`
- Controller는 Repository에 직접 의존하지 않는다.
- Repository는 Service에 의존하지 않는다.
- 하위 계층의 컴포넌트는 Controller에 의존하지 않는다.
- 도메인 객체는 웹 프레임워크의 타입에 의존하지 않도록 한다.
- DTO와 도메인 객체는 각 계층의 책임에 맞게 사용할 수 있다.
## 4. 트랜잭션 관리
- 트랜잭션의 경계는 애플리케이션의 Service 계층에서 정의한다.
- 트랜잭션의 범위는 가능한 한 작게 유지한다.
- 데이터베이스 트랜잭션 내부에서 불필요한 외부 API 호출을 수행하지 않는다.
- 여러 작업이 공유 데이터를 변경하는 경우 데이터 정합성을 고려한다.
## 5. 예외 처리
- API 전반에 걸쳐 일관된 예외 처리 방식을 사용한다.
- 비즈니스 규칙 위반과 예상하지 못한 시스템 오류를 구분한다.
- 내부 예외의 상세 정보가 클라이언트에 노출되지 않도록 한다.
- 오류 상황에 적절하고 의미 있는 HTTP 상태 코드를 사용한다.
## 6. 유지보수성
- 클래스는 가능한 한 작게 유지하고, 책임을 명확하게 정의한다.
- 동일한 비즈니스 규칙이 여러 곳에 중복 구현되지 않도록 한다.
- 필요성이 확인되지 않은 성급한 일반화나 추상화를 피한다.
- 기능의 동작을 쉽게 테스트할 수 있도록 설계한다.
- 명확한 이유 없이 아키텍처의 복잡도를 높이지 않는다.
coding-conventions.md
# Coding Conventions
## 1. 기본 원칙
- 필요한 경우 Java 21에서 제공하는 기능을 적절하게 활용한다.
- Java의 표준 네이밍 컨벤션을 따른다.
- 복잡하고 기교적인 코드보다 읽기 쉽고 이해하기 쉬운 코드를 우선한다.
- 클래스, 메서드, 변수의 이름은 역할과 의미가 명확하게 드러나도록 작성한다.
- 불필요한 복잡성을 피한다.
- 사용하지 않는 import 문과 불필요한 코드를 제거한다.
## 2. 클래스 설계
- 각 클래스는 명확한 책임을 갖도록 설계한다.
- 의존성 주입은 생성자 주입 방식을 우선한다.
- 필드 주입 방식은 사용하지 않는다.
- 의존성을 나타내는 필드는 가능한 한 `final`로 선언한다.
- 명확한 필요성이 없다면 불필요한 인터페이스를 도입하지 않는다.
## 3. Spring 컴포넌트
### Controller
- REST API를 구현할 때는 `@RestController`를 사용한다.
- API 요청과 응답에는 각각 DTO를 사용한다.
- 클라이언트의 요청 데이터는 Bean Validation을 활용하여 검증한다.
- 처리 결과에 적절한 HTTP 응답을 반환한다.
### Service
- 필요한 경우 `@Service`를 사용하여 서비스 컴포넌트를 정의한다.
- 애플리케이션의 비즈니스 로직은 Controller와 분리한다.
- 트랜잭션 경계가 필요한 경우 `@Transactional`을 사용한다.
- 읽기 전용 작업에는 필요한 경우 `@Transactional(readOnly = true)`를 사용한다.
### Repository
- 데이터 접근 계층은 필요한 경우 Spring Data JPA를 활용한다.
- 데이터 조회 및 저장을 위한 쿼리와 비즈니스 로직을 분리한다.
- 불필요한 커스텀 쿼리 작성을 피한다.
## 4. DTO
- 변경할 필요가 없는 API DTO는 적절한 경우 Java의 `record` 사용을 우선한다.
- 데이터 검증에 필요한 제약조건을 명시적으로 선언한다.
- JPA 엔티티를 API 응답으로 직접 반환하지 않는다.
- 내부 구현 정보나 민감한 데이터가 외부에 노출되지 않도록 한다.
## 5. 예외 처리
- 오류의 원인을 명확하게 표현할 수 있는 예외를 사용한다.
- 예상 가능한 애플리케이션 오류는 일관된 방식으로 처리한다.
- 명확한 처리 목적 없이 예외를 포착하지 않는다.
- 발생한 오류를 아무런 처리 없이 무시하지 않는다.
## 6. 데이터베이스
- 필요한 경우 데이터베이스 수준에서 제약조건을 정의한다.
- 데이터 정합성을 애플리케이션 수준의 유효성 검증에만 의존하지 않는다.
- 공유 데이터를 변경하는 경우 동시 요청으로 인해 발생할 수 있는 문제를 고려한다.
- 불필요한 데이터베이스 쿼리가 발생하지 않도록 한다.
## 7. 코드 변경
- 기존 프로젝트에서 사용하고 있는 네이밍 및 코드 포맷팅 규칙을 따른다.
- 요청된 작업과 관련된 부분만 수정한다.
- 작업과 관련 없는 리팩토링은 수행하지 않는다.
- 명시되지 않은 기능을 추측하여 추가하지 않는다.
security.md
# Security Guidelines
## 1. 기본 원칙
- 비밀번호, 인증 정보, API 키 등의 민감한 정보를 코드에 하드코딩하지 않는다.
- 비밀번호, Access Token, Refresh Token, Secret Key 등을 로그에 기록하지 않는다.
- 최소 권한 원칙(Principle of Least Privilege)을 따른다.
- 신뢰할 수 없는 모든 입력 데이터에 대해 유효성을 검증한다.
- 유효하지 않은 인증 요청은 거부한다.
- OWASP TOP 10의 포함된 주요 취약점을 예방한다.
## 2. 비밀번호 보안
- 비밀번호를 평문(Plaintext)으로 저장하지 않는다.
- 안전한 비밀번호 해싱 알고리즘을 사용한다.
- 비밀번호 해시 값을 API 응답으로 노출하지 않는다.
- 로그나 예외 메시지에 비밀번호를 포함하지 않는다.
## 3. 인증(Authentication)
- 사용자의 인증 정보를 안전한 방식으로 검증한다.
- 인증 실패 메시지를 통해 특정 계정의 존재 여부가 드러나지 않도록 한다.
- 인증 정보가 누락되었거나 유효하지 않거나 만료된 경우 요청을 거부한다.
- 인증 실패 시 일관된 형식의 오류 응답을 반환한다.
## 4. 토큰 보안
- 토큰의 서명과 만료 여부를 검증한다.
- 검증되지 않은 토큰에 포함된 정보를 신뢰하지 않는다.
- 임의의 값을 사용하는 불투명 토큰(Opaque Token)을 생성할 때는 보안적으로 안전한 난수 생성 방식을 사용한다.
- 장기간 유효한 인증 정보는 안전하게 보호한다.
- 권한이 없는 토큰 재사용을 방지한다.
- 인증에 사용되는 Secret Key 등의 민감한 정보는 소스 코드 외부에서 관리한다.
## 5. 인가(Authorization)
- 보호가 필요한 리소스에는 적절한 접근 제어를 적용한다.
- 클라이언트가 전달한 사용자 식별자를 별도의 권한 검증 없이 신뢰하지 않는다.
- 사용자가 권한 없이 다른 사용자의 리소스를 수정하거나 접근할 수 없도록 한다.
## 6. 세션 관리
- 세션의 만료 조건과 동작을 명확하게 정의한다.
- API 명세에 따라 인증 정보를 적절하게 무효화한다.
- 서로 독립적인 세션의 경계가 유지되도록 한다.
- 동시 요청으로 발생할 수 있는 문제와 재전송 공격(Replay Attack)을 고려한다.
## 7. 예외 처리
- 인증 실패 상황에 적절한 오류 응답을 반환한다.
- 내부 구현에 대한 상세 정보가 외부에 노출되지 않도록 한다.
- 스택 트레이스(Stack Trace)나 로그를 통해 민감한 정보가 유출되지 않도록 한다.
testing.md
# Testing Guidelines
## 1. 테스트 기본 원칙
- 내부 구현 방식보다 외부에서 관찰할 수 있는 동작을 중심으로 테스트한다.
- 정상적으로 동작하는 경우뿐만 아니라 실패하는 경우도 검증한다.
- 필요한 경우 경계값과 예외적인 조건을 테스트한다.
- 실행할 때마다 동일한 결과를 얻을 수 있는 결정적인 테스트를 우선한다.
- 각 테스트는 서로 독립적이어야 하며 반복 실행이 가능해야 한다.
## 2. 단위 테스트(Unit Test)
- 가능한 경우 비즈니스 규칙을 다른 컴포넌트와 분리하여 독립적으로 테스트한다.
- 정상적인 동작과 예상 가능한 실패 상황을 모두 검증한다.
- 단순한 객체까지 불필요하게 Mock으로 대체하지 않는다.
- 각 테스트는 하나의 명확한 동작을 검증하도록 작성한다.
## 3. 통합 테스트(Integration Test)
- 관련 컴포넌트 간의 상호작용을 테스트한다.
- 필요한 경우 데이터의 저장 및 조회 등 영속성 동작을 검증한다.
- HTTP 응답의 상태 코드와 응답 본문을 검증한다.
- 인증 및 인가를 포함한 보안과 접근 제어 동작을 검증한다.
- 테스트 목적에 적합한 환경과 인프라를 사용한다.
## 4. 회귀 테스트(Regression Test)
- 명시적으로 변경된 요구사항이 없다면 기존 동작을 유지한다.
- 코드 변경으로 영향을 받는 테스트를 다시 실행한다.
- 새로운 기능이 기존 API의 동작에 영향을 주지 않는지 확인한다.
## 5. 동시성 테스트(Concurrency Test)
동시성 문제가 발생할 가능성이 있는 경우 다음 원칙을 따른다.
- 실제로 여러 작업이 동시에 실행되는 환경을 구성하여 테스트한다.
- 필요한 경우 각 스레드의 시작 시점을 동기화한다.
- `Thread.sleep()`에만 의존하여 동시 실행을 제어하지 않는다.
- 동시 요청이 완료된 후 데이터베이스에 저장된 최종 상태를 검증한다.
- 실행 시점에 따라 결과가 달라지는 비결정적 오류를 분석하기 위해 테스트를 반복 실행한다.
- 필요한 경우 운영 환경과 관련된 트랜잭션 동작을 재현할 수 있는 데이터베이스를 사용한다.
## 6. 검증 절차
코드 변경을 완료한 후 다음 순서에 따라 검증하라.
1. 변경사항과 관련된 테스트를 실행한다.
2. 테스트 실패가 발생하면 원인을 분석한다.
3. 이번 변경으로 인해 발생한 문제를 수정한다.
4. 실패했던 테스트를 다시 실행한다.
5. 전체 검증 명령어를 실행한다.
6. 최종 실행 결과를 확인한다.
## 7. 작업 완료 기준
- 실제로 테스트를 실행하지 않았다면 테스트가 통과했다고 보고하지 않는다.
- 실패한 테스트가 있다면 해당 내용을 정확하게 보고한다.
- 빌드를 통과시키기 위해 테스트를 임의로 비활성화하지 않는다.
- 검증을 통과시키기 위한 목적으로 테스트의 Assertion을 임의로 제거하지 않는다.
- 테스트를 실행할 수 없는 경우 그 이유를 명확하게 설명한다.
- 테스트하지 않은 동작과 실제로 검증이 완료된 동작을 명확하게 구분한다.
planning.md
# Planning Guidelines
## 1. 계획 수립 기준
다음과 같은 작업을 수행하는 경우 문서화된 실행 계획을 수립한다.
- 여러 컴포넌트를 변경해야 하는 작업
- 아키텍처에 중요한 변경사항이 발생하는 작업
- 동시성 문제나 복잡한 상태 전환을 다루는 작업
- 데이터베이스의 여러 변경사항을 함께 조정해야 하는 작업
- 기술적으로 불확실성이 크거나 사전 검토가 필요한 작업
단순한 코드 수정이나 작은 규모의 작업에는 별도의 실행 계획을 작성하지 않는다.
## 2. 계획서 구성
실행 계획에는 다음 내용을 포함한다.
### 목표(Goal)
- 작업을 통해 달성해야 하는 목표를 명확하게 정의한다.
### 작업 범위(Scope)
- 변경하거나 구현해야 하는 기능과 컴포넌트를 정의한다.
### 제약사항(Constraints)
- 작업 과정에서 반드시 준수해야 하는 요구사항과 규칙을 정리한다.
- 기존 동작 중 유지해야 하는 사항을 명확하게 한다.
### 구현 단계(Implementation Steps)
- 목표를 달성하기 위해 필요한 주요 구현 단계를 정리한다.
- 각 단계에서 수행해야 할 작업을 명확하게 작성한다.
### 검증 방법(Verification)
- 구현 결과가 요구사항을 충족하는지 확인할 방법을 정의한다.
- 필요한 테스트와 검증 절차를 정리한다.
### 위험 요소(Risks)
- 작업 과정에서 발생할 수 있는 문제와 실패 가능성을 식별한다.
## 3. 계획 실행
- 실행 계획은 불필요하게 길어지지 않도록 간결하게 작성한다.
- 작업을 작은 단위로 나누어 진행하고, 각 단계에서 결과를 검증한다.
- 기존 가정이나 작업 조건이 변경되면 실행 계획을 수정한다.
- 명확한 이유 없이 작업 범위를 확장하지 않는다.
- 필요한 경우 중요한 기술적 결정과 그 이유를 기록한다.
## 4. 작업 완료
복잡한 작업을 완료하기 전에 다음 사항을 확인하라
- 계획한 구현 단계가 모두 수행되었는지 확인
- 정의된 인수 조건(Acceptance Criteria)을 충족하는지 검증
- 해결되지 않은 문제나 제약사항을 기록
- 최종 구현 결과가 최초 요구사항과 일치하는지 확인
verify.sh
#!/usr/bin/env bash
set -euo pipefail
echo "================================="
echo " Spring Boot Verification"
echo "================================="
echo "[1/2] Cleaning previous build..."
./gradlew --no-daemon clean
echo "[2/2] Building and testing..."
./gradlew --no-daemon build
echo "================================="
echo " Verification PASSED"
echo "================================="
1차 실험 - 회원가입 및 로그인
공통 프롬프트
# 작업: Spring Boot 회원가입 및 로그인 기능 구현
현재 프로젝트는 Spring Boot로 생성한 초기 프로젝트입니다.
이 프로젝트에 회원가입, 로그인, JWT 기반 인증, 내 정보 조회 기능을 구현해 주세요.
## 기술 환경
- Java 21
- Spring Boot 4.1.1
- Gradle
- Spring Web
- Spring Security
- Spring Data JPA
- Spring Validation
- H2 Database
필요한 의존성은 추가해도 됩니다.
## 1. 회원가입
**POST /api/auth/signup**
요청:
{
"email": "test@example.com",
"password": "password123",
"name": "홍길동"
}
요구사항:
- 이메일, 비밀번호, 이름을 입력받아 회원을 생성합니다.
- 이메일은 올바른 형식이어야 합니다.
- 이메일의 앞뒤 공백을 제거하고 소문자로 정규화합니다.
- 이메일은 중복될 수 없습니다.
- 비밀번호는 8자 이상이어야 합니다.
- 이름은 공백만으로 구성될 수 없습니다.
- 비밀번호는 BCrypt로 해싱하여 저장합니다.
- 성공 시 HTTP 201을 반환합니다.
- 입력값 검증 실패 시 HTTP 400을 반환합니다.
- 이메일 중복 시 HTTP 409를 반환합니다.
- 응답에 비밀번호 및 비밀번호 해시를 포함하지 않습니다.
## 2. 로그인
**POST /api/auth/login**
요청:
{
"email": "test@example.com",
"password": "password123"
}
요구사항:
- 이메일과 비밀번호를 검증합니다.
- 이메일은 회원가입과 동일한 방식으로 정규화합니다.
- 인증에 성공하면 JWT Access Token을 발급합니다.
- JWT 서명 알고리즘은 HS256을 사용합니다.
- Access Token 만료 시간은 1시간입니다.
- JWT 서명 키는 환경변수로 관리합니다.
- 이메일 또는 비밀번호가 올바르지 않으면 HTTP 401을 반환합니다.
- 존재하지 않는 이메일과 잘못된 비밀번호에 대해 계정 존재 여부가 드러나지 않도록 동일한 오류 응답을 사용합니다.
성공 응답:
{
"accessToken": "...",
"tokenType": "Bearer"
}
## 3. 내 정보 조회
**GET /api/users/me**
요구사항:
- Authorization 헤더에 Bearer Token을 전달받습니다.
- 유효한 JWT로 인증된 사용자만 접근할 수 있습니다.
- 정상 인증 시 HTTP 200을 반환합니다.
- 응답에는 회원 ID, 이메일, 이름을 포함합니다.
- JWT가 없거나 위조되었거나 만료되었다면 HTTP 401을 반환합니다.
- 비밀번호와 비밀번호 해시는 절대 노출하지 않습니다.
## 4. 공통 요구사항
- REST API로 구현합니다.
- Spring Security를 사용합니다.
- Controller, Service, Repository 등의 책임을 적절하게 분리합니다.
- JPA를 이용해 데이터를 저장합니다.
- 별도의 외부 DB 서버 없이 H2로 실행할 수 있어야 합니다.
- 민감한 정보를 소스 코드에 하드코딩하지 않습니다.
- 예외 상황에 적절한 HTTP 상태 코드를 반환합니다.
- 정상 및 예외 상황에 대한 자동화 테스트를 작성합니다.
- 기존에 제공된 기능이 있다면 불필요하게 변경하지 않습니다.
## 5. 작업 진행 방식
프로젝트 구조와 환경을 확인한 뒤 구현을 진행해 주세요.
구현 후 빌드와 테스트를 실행하고 문제가 발생하면 원인을 확인하여 수정해 주세요.
작업 완료 시 다음 내용을 보고해 주세요.
1. 구현한 기능
2. 주요 패키지 및 클래스 구조
3. 실행한 테스트와 실제 결과
4. 미해결 문제 또는 제한사항
필요한 설계와 구현 방식은 스스로 판단해 주세요. 추가 질문 없이 작업을 완료해 주세요.
1. 개발 효율성 비교
처음에는 codex exec --json으로 저장한 harness.jsonl의 turn.completed.usage만 비교했다.
해당 기록에는 Harness의 메인 오케스트레이터 사용량 483,813토큰이 나타났지만, 이를 전체 사용량으로 간주하면 Planner, Generator, Evaluator의 별도 사용량이 제외된다.
이후 Codex 로컬 세션 로그에서 세 서브 에이전트의 누적 사용량과 역할을 확인하여 아래 표에 합산했다.
| 측정 항목 | No Harness | Harness (메인 + 서브 에이전트 3개) |
|---|---|---|
| Codex 실행 시간 | 267초 | 338초 |
| Input Tokens | 1,643,530 | 1,988,146 |
| Cached Input Tokens | 1,592,448 | 1,874,304 |
| Output Tokens | 18,278 | 19,186 |
| Reasoning Output Tokens | 3,340 | 4,912 |
| 총 토큰 (Input + Output) | 1,661,808 | 2,007,332 |
Harness 에이전트별 토큰 사용량
| 에이전트 | Input Tokens | Cached Input Tokens | Output Tokens | Reasoning Output Tokens | 총 토큰 |
|---|---|---|---|---|---|
| Main Orchestrator | 481,020 | 454,272 | 2,793 | 454 | 483,813 |
| Planner (Avicenna) | 91,416 | 66,048 | 1,111 | 149 | 92,527 |
| Generator (Tesla) | 1,214,130 | 1,171,584 | 13,247 | 3,532 | 1,227,377 |
| Evaluator (Archimedes) | 201,580 | 182,400 | 2,035 | 777 | 203,615 |
| 합계 | 1,988,146 | 1,874,304 | 19,186 | 4,912 | 2,007,332 |
세 서브 에이전트의 세션 메타데이터에는 동일한 부모 세션 ID(01a119f7-9409-7092-96a7-0bfaac738d3e)가 기록되어 있다.
다만 harness.jsonl의 thread.started.thread_id가 이 ID와 일치하는지 마지막으로 대조하면 집계의 연결 관계를 더욱 명확하게 확인할 수 있다.
집계 방법:
총 토큰은 Input + Output으로 계산한다.
Cached Input Tokens는 Input에 포함되고,
Reasoning Output Tokens는 Output에 포함되므로 별도로 더하지 않는다.
에이전트별 로컬 로그의 마지막 누적 사용량을 사용했으며, 각 세션의 계수가 독립적이라는 전제에서 합산했다.
시간 비교
Harness는 No Harness보다 71초(약 26.6%) 더 오래 걸렸다.
이는 Codex 실행 구간의 시간이며, 이후 사람이 별도로 실행한 로컬 빌드와 외부 기능 평가 시간은 포함하지 않는다.
Planner, Generator, Evaluator가 추가로 실행되었지만, 현재 기록만으로 어느 단계가 시간 증가에 얼마나 기여했는지는 단정할 수 없다.
토큰 비교
전체 에이전트의 기록을 합산하면 Harness는 2,007,332토큰으로 No Harness의 1,661,808토큰보다 345,524토큰(약 20.8%) 더 사용했다.
처음에 보였던 Harness의 큰 토큰 감소는 메인 오케스트레이터의 사용량만 비교해서 생긴 실수였다.
실제로는 Generator가 Harness 전체 토큰의 약 61.1%를 사용했다.
다만 토큰 수와 API 비용은 같지 않다. 두 조건 모두 캐시된 입력 토큰의 비중이 높으므로, 실제 비용 비교에는 캐시 적용 단가와 각 에이전트의 모델 정보를 추가로 확인해야 한다.
2. 기능 정확성 비교
동일한 외부 API 평가 프로그램을 이용해 결과를 검증했다.
| 평가 항목 | No Harness | Harness |
|---|---|---|
| 정상 회원가입 | PASS | PASS |
| 잘못된 이메일 | FAIL | PASS |
| 8자 미만 비밀번호 | FAIL | PASS |
| 공백만 있는 이름 | FAIL | PASS |
| 중복 이메일 | PASS | PASS |
| 이메일 정규화 후 중복 | PASS | PASS |
| BCrypt 해시 저장 | 미평가 | 미평가 |
| 응답에 비밀번호 미포함 | PASS | PASS |
| 정상 로그인 | PASS | PASS |
| 잘못된 비밀번호 | PASS | PASS |
| 존재하지 않는 이메일 | PASS | PASS |
| 정상 내 정보 조회 | PASS | PASS |
| Access Token 누락 | PASS | PASS |
| 변조된 JWT | PASS | PASS |
| 만료된 JWT | PASS | PASS |
| JWT 환경변수 관리 | 미평가 | 미평가 |
자동 평가 결과
- No Harness: 11개 통과, 3개 실패 (78.6%)
- Harness: 14개 통과, 0개 실패 (100%)
- 통과율 차이: 21.4%p
BCrypt 저장 여부와 JWT 비밀 키 관리 항목은 별도 검사가 필요하므로 최종 16개 평가 항목 전체에 대한 통과율은 확정하지 않았다.
No Harness에서 발견한 문제
회원가입 입력값 검증과 관련된 세 가지 테스트에서 요구사항과 다른 HTTP 상태 코드가 반환되었다.
- 이메일 형식 오류: 예상 400 → 실제 401
- 비밀번호 길이 오류: 예상 400 → 실제 401
- 이름 공백 오류: 예상 400 → 실제 401
세 항목 모두 HTTP 400 Bad Request를 반환해야 하지만 HTTP 401 Unauthorized를 반환했다.
인증/보안 처리와 입력값 검증의 상호작용이 원인일 가능성이 있지만, 현재 기록만으로 정확한 원인은 확인되지 않았다.
3. 빌드 및 테스트 결과
No Harness
Codex 실행 중 Gradle 캐시 및 샌드박스 환경 문제로 전체 빌드와 테스트를 완료하지 못했다.
이후 로컬에서 ./gradlew clean build를 실행한 결과:
- 테스트 5개 실행
- 테스트 1개 실패
- 최종 빌드 실패
- 실패 테스트:
AuthApiTests.signupRejectsInvalidInputs()
Harness
Codex 실행 중에는 마찬가지로 Gradle 캐시 및 로컬 소켓 생성 제한으로 필수 검증을 완료하지 못했다.
최종 Codex 보고 상태는 BLOCKED였다.
이후 로컬에서 ./gradlew clean build를 실행한 결과 빌드에 성공했다.
Evaluator는 정적 검토 과정에서 Critical/Major 문제를 보고하지 않았으며, 수정 재위임은 0회로 기록되었다.
중요한 차이
두 조건 모두 AI 작업 환경 안에서는 전체 Gradle 검증을 완료하지 못했다.
하지만 동일한 개발자 로컬 환경에서 별도로 실행한 결과는 달랐다.
- No Harness: 빌드 실패
- Harness: 빌드 성공
따라서 AI가 보고한 검증 상태와 실제 결과물을 독립적으로 검증한 결과는 구분해서 기록해야 한다.
4. 결과 분석
4.1 기능 정확성
이번 실행에서 Harness 결과물은 자동으로 검증 가능한 14개 기능 평가를 모두 통과했다.
반면 No Harness 결과물은 세 가지 입력값 검증에서 실패했다.
따라서 이번 실험에서는 Harness 결과물이 요구사항을 더 정확하게 만족했다.
4.2 개발 시간
Harness의 실행 시간이 26.6% 더 길었다.
이는 멀티 에이전트 오케스트레이션의 추가 비용이 발생할 수 있음을 보여주지만, 각 역할의 실행 시간 기록이 없어 정확한 원인을 단정할 수 없다.
4.3 토큰 소비량
초기에는 harness.jsonl에 기록된 메인 오케스트레이터의 483,813토큰만 확인하여 Harness가 더 적은 토큰을 사용한 것처럼 보였다.
하지만 세 서브 에이전트의 로컬 세션 사용량을 더한 결과 Harness의 총 기록 사용량은 2,007,332토큰으로, No Harness 대비 약 20.8% 증가했다.
즉, 멀티 에이전트가 메인 세션의 부담을 분산했다고 하더라도 시스템 전체의 토큰 사용량이 줄어든 것은 아니었다.
동시에 외부 자동 평가에서는 Harness가 14/14개, No Harness가 11/14개를 통과했다.
이번 실험에서는 더 많은 토큰과 실행 시간을 사용한 Harness가 더 높은 기능 정확성을 보였다고 정리할 수 있다.
다만 한 번의 실행으로 원인 관계나 일반적인 성능 우위를 단정할 수는 없다.
4.4 검증 과정
두 실험 모두 Codex 내부 실행 환경의 제약으로 전체 Gradle 검증을 수행하지 못했다.
하지만 개발 완료 후 독립적인 테스트에서 결과 차이가 확인되었다.
이 사례는 에이전트의 완료 보고뿐 아니라 실제 결과물을 별도로 검증하는 과정이 중요하다는 점을 보여준다.
5. 실험의 한계
이번 실험에는 다음과 같은 한계가 있다.
- 각 조건을 한 번씩만 실행했으므로 결과의 재현성을 확인하지 못했다.
- 세 서브 에이전트의 토큰 사용량은 확인했으나, 메인 세션 ID와의 최종 대조 및 캐시 단가를 반영한 실제 비용 산출은 남아 있다.
- 두 조건 모두 Codex 내부에서는 Gradle 검증에 환경 제약이 발생했다.
- BCrypt 및 JWT 환경변수 관리 항목은 아직 별도로 검증하지 않았다.
- 프로젝트 지침, 검증 절차, 오케스트레이션을 함께 적용했으므로 어떤 요소가 개선에 기여했는지 분리할 수 없다.
6. 결론
이번 1차 예비 실험에서는 추가 하네스를 적용한 Codex가 더 많은 토큰과 시간을 사용했지만, 외부 자동 기능 평가에서는 더 높은 정확성을 보였다.
- 기능 정확성: Harness 14/14개 통과(100%), No Harness 11/14개 통과(78.6%). 두 조건 모두 A07(BCrypt 저장)과 A16(JWT 비밀 키 관리)은 미평가 상태다.
- 로컬 빌드: Harness 성공, No Harness 실패(테스트 5개 중 1개 실패).
- 실행 시간: Harness 338초, No Harness 267초 → Harness 약 26.6% 증가.
- 기록된 총 토큰: Harness 2,007,332개, No Harness 1,661,808개 → Harness 약 20.8% 증가(메인 + 서브 에이전트 합산 기준).
두 조건 모두 Codex 작업 환경에서는 Gradle 검증이 차단되었으나, 이후 동일한 로컬 환경에서 독립적으로 검증한 결과 차이가 확인되었다.
따라서 이번 실행에서는 Harness 결과물의 기능 정확성이 높았지만, 더 높은 토큰·시간 비용이 발생했다고 해석할 수 있다.
다만 실제 금액 기준의 비용 효율성은 캐시 토큰 단가와 모델별 요금을 반영해야 평가할 수 있다.
한 번의 실험 결과만으로 하네스가 일반적으로 더 정확하거나 효율적이라고 단정할 수는 없다.
다음 실험에서는 메인·서브 에이전트의 사용량을 처음부터 함께 기록하고, 실험을 반복하며, 미평가 보안 항목도 독립 검증할 예정이다.