임베디드에서 AI Agents: 전체 파이프라인을 열어 본다
AI 에이전트로 만든 i.MX8M Plus 센서 드라이버 프로젝트를 폴더째 열어 본다. 폴더 구조, 스펙, property-based 테스트, 리뷰 에이전트, 피드백 루프가 맞물리는 방식.
On this page
첫 번째 포스트에서 나는 스펙을 기준으로 도는 피드백 루프를 만들었다. 마크다운에 인수 기준을 적고, JSON을 내놓는 테스트 래퍼를 두고, 에이전트가 그 구조화된 결과를 보며 반복하는 구조였다. 두 번째 포스트에서는 그 위에 컨텍스트를 세 층으로 쌓았다. 하드웨어 제약을 담은 CLAUDE.md, 리뷰만 맡는 서브에이전트, 그리고 컴파일러를 루프 안에 넣은 피드백이다.
두 글은 각 조각이 왜 필요한지를 설명했다. 그런데 폴더를 실제로 열었을 때 프로젝트가 어떤 모습인지는 보여 주지 않았다. 이 글은 그 빈자리를 채우려고 쓴다. 프로젝트 하나와 그 안의 파일 전부, 그리고 그것들이 어떻게 맞물리는지.
대상은 i.MX8M Plus용 IMU 센서 드라이버다. SPI에 DMA를 쓰고, Yocto scarthgap으로 빌드하고, Raspberry Pi 4에서 돌려 테스트했다. 개발은 처음부터 끝까지 Claude Code로 했다. 앞의 두 글에서 예제로 계속 써 온 바로 그 드라이버를, 이번에는 통째로 뜯어 본다.
프로젝트 트리
sensor-driver/
├── CLAUDE.md
├── .claude/
│ ├── rules/
│ │ ├── kernel.md
│ │ ├── dts.md
│ │ └── test.md
│ └── agents/
│ ├── supervisor.md
│ ├── concurrency-reviewer.md
│ ├── register-contract-reviewer.md
│ ├── side-effect-reviewer.md
│ ├── coding-standard-reviewer.md
│ └── test-coverage-reviewer.md
├── specs/
│ └── imu-driver.md
├── tests/
│ ├── conftest.py
│ ├── inventory.yaml
│ ├── test_imu_driver.py
│ ├── test_imu_properties.py
│ ├── test_imu_hil.py
│ └── fuzz/
│ ├── corpus/
│ └── harness_spi_parser.c
├── scripts/
│ ├── run_target_tests.sh
│ └── static_analysis.sh
├── docs/
│ └── hardware/
│ └── imu-register-map.md
├── drivers/
│ └── imu/
│ ├── imu_core.c
│ ├── imu_dma.c
│ ├── imu_spi.c
│ └── imu.h
└── meta-sensor/
└── recipes-kernel/
└── linux-imx/
└── sensor-driver.bbappend
디렉토리마다 파이프라인에서 맡는 역할이 다르다. 개발 사이클 한 번 동안 에이전트가 이 폴더들을 만나는 순서대로 따라가 보면 구조가 잘 보인다.
에이전트가 세션마다 가장 먼저 읽는 것은 CLAUDE.md다. 20줄 남짓한 파일이고, 하드웨어 제약과 학습된 수정만 담는다. 프로젝트 구조 설명은 넣지 않았다. 그건 에이전트가 저장소를 보고 스스로 추론한다. 자세한 이야기는 컨텍스트 엔지니어링 포스트에 적었다. 그 옆의 .claude/rules/는 맞는 파일을 편집할 때만 불러오는, 범위가 정해진 컨텍스트다. kernel.md는 drivers/**/*.c에, dts.md는 *.dts와 *.dtsi에, test.md는 tests/**/*.py에 걸린다. CLAUDE.md 한 곳에 다 모으지 않고 컨텍스트를 작게 나눠서, 저마다 한 가지에만 집중하게 했다.
.claude/agents/에는 특화 리뷰어 5개와 감독자의 시스템 프롬프트가 있다. 파일 하나가 에이전트 하나의 역할과 체크리스트를 정하고, 거기서 멈춘다. 동시성 리뷰어와 레지스터 계약 리뷰어는 같은 것을 두 번 확인하려고 각각 인스턴스 2개를 병렬로 띄우고, 나머지 3개는 하나씩만 돈다. 모든 인스턴스의 결과는 감독자가 모은다.
에이전트가 무엇을 만들지는 specs/에 적는다. 마크다운 테이블로 적은 인수 기준이 드라이버나 모듈 하나에 파일 하나씩 있고, 에이전트는 이것을 근거로 테스트를 만든다. 그렇게 나온 테스트는 tests/에 네 종류로 모여 있다. test_imu_driver.py는 스펙 기반 예제 테스트, test_imu_properties.py는 property-based 테스트(Hypothesis + CFFI), fuzz/는 AFL++ 하네스다. 같은 폴더의 conftest.py와 inventory.yaml은 타겟에 접근하려고 labgrid를 설정해 둔 파일이다.
테스트는 scripts/의 래퍼 스크립트 두 개로 돌린다. run_target_tests.sh는 모듈을 배포하고 pytest를 돌린 뒤 JSON을 돌려주고, static_analysis.sh는 cppcheck와 clang-tidy를 돌려 결과를 JSON으로 내놓는다. docs/hardware/에는 데이터시트에서 뽑아 둔 레지스터 맵, 에라타 노트, 핀아웃 다이어그램이 있는데, 레지스터 계약 리뷰어가 리뷰하면서 이곳을 참조한다.
실제 드라이버 소스는 drivers/imu/에 있고, 코어 로직, DMA 처리, SPI 통신으로 관심사에 따라 나눠 두었다. meta-sensor/는 Yocto 레이어다. 그 안의 .bbappend가 드라이버를 BSP 빌드에 끼워 넣는다.
스펙
모든 것이 여기서 시작된다. 에이전트가 드라이버 코드를 한 줄 쓰기 전부터 이 파일은 이미 있다.
# IMU Sensor Driver (ICM-42688-P) Acceptance Criteria
## Target
- SoC: i.MX8M Plus (Cortex-A53)
- Interface: SPI (mode 3, 10MHz)
- DMA: SDMA channel, 64-byte aligned buffers
- Test board: Raspberry Pi 4 (Yocto scarthgap, kernel 6.1 LTS)
| ID | Criterion | Metric | Method |
|---|---|---|---|
| AC-1 | Sampling rate 1kHz within 1% tolerance | sample count per second | sysfs counter over 10s |
| AC-2 | Data integrity after 10K DMA transfers | CRC32 match rate = 100% | CRC on raw buffer vs parsed |
| AC-3 | RSS memory < 2MB after 1hr soak | /proc/meminfo delta | stress-ng + periodic sample |
| AC-4 | Recovery within 3s after SPI bus error | time to first valid read | unbind/rebind SPI device |
| AC-5 | IRQ-to-userspace latency < 500us (p99) | timestamp delta | cyclictest-style measurement |
| AC-6 | No data loss under CPU stress | sample gap detection | stress-ng —cpu 4 + counter |
## Constraints
- Kernel 6.1 LTS: no spi-fault-inject module available
- DMA buffers: 64-byte aligned (L1 cache line on Cortex-A53)
- SPI mode 3 (CPOL=1, CPHA=1) for ICM-42688-P
- CTRL_REG1 at 0x4E (not 0x11 as in MPU-6050)
제약 사항 섹션은 기준만큼이나 중요하다. 이 섹션이 있으면 에이전트가 없는 도구를 쓰거나 하드웨어를 잘못 설정하는 테스트를 만들지 않는다. 여기 적힌 제약은 하나하나가 개발 중에 실제로 무언가 깨졌던 자리에서 나왔다.
네 개의 테스트 계층
스펙에서 예제 기반 테스트가 나온다. 하지만 예제 기반 테스트는 내가 직접 짚어 적어 둔 시나리오만 다룬다. 그래서 테스트를 네 계층으로 두고, 아래로 갈수록 더 깊은 곳의 버그를 잡게 했다.
계층 1: Property-Based 테스트 (밀리초, 호스트)
이 테스트는 호스트 머신에서, 공유 라이브러리로 컴파일한 C 코드를 상대로 돈다. 타겟 하드웨어는 필요 없다. CFFI는 파이썬에서 C 함수를 바로 부르는 외부 함수 인터페이스로, 컴파일된 C를 곧장 불러온다. 그러면 Hypothesis가 입력을 수천 개씩 만들어 넣고, 실패가 나오면 가장 작은 케이스로 줄여 준다. 설치는 pip install cffi hypothesis 한 줄이면 된다.
# tests/test_imu_properties.py
from hypothesis import given, strategies as st, settings
import cffi
ffi = cffi.FFI()
ffi.cdef("""
typedef struct {
int16_t accel[3];
int16_t gyro[3];
uint32_t timestamp;
uint8_t status;
} imu_sample_t;
int parse_imu_frame(const uint8_t *buf, int len, imu_sample_t *out);
int build_imu_frame(const imu_sample_t *sample, uint8_t *buf, int max_len);
""")
lib = ffi.dlopen("./build/libimu_host.so")
@given(data=st.binary(min_size=1, max_size=64))
def test_parser_never_crashes(data):
"""No input -- valid, truncated, or garbage -- should crash the parser."""
buf = ffi.new("uint8_t[]", data)
sample = ffi.new("imu_sample_t *")
ret = lib.parse_imu_frame(buf, len(data), sample)
assert ret in (0, -1)
@given(
accel=st.tuples(*[st.integers(-32768, 32767)] * 3),
gyro=st.tuples(*[st.integers(-32768, 32767)] * 3),
ts=st.integers(0, 2**32 - 1),
)
def test_roundtrip_preserves_values(accel, gyro, ts):
"""Encode then decode must recover the original values."""
sample_in = ffi.new("imu_sample_t *")
for i in range(3):
sample_in.accel[i] = accel[i]
sample_in.gyro[i] = gyro[i]
sample_in.timestamp = ts
buf = ffi.new("uint8_t[64]")
n = lib.build_imu_frame(sample_in, buf, 64)
assert n > 0
sample_out = ffi.new("imu_sample_t *")
assert lib.parse_imu_frame(buf, n, sample_out) == 0
assert tuple(sample_out.accel) == accel
assert tuple(sample_out.gyro) == gyro
assert sample_out.timestamp == ts
@given(data=st.binary(min_size=1, max_size=15))
@settings(max_examples=10000)
def test_short_frames_rejected(data):
"""Frames shorter than minimum valid length must return -1."""
buf = ffi.new("uint8_t[]", data)
sample = ffi.new("imu_sample_t *")
# minimum frame: header(2) + payload(12) + crc(2) = 16 bytes
assert lib.parse_imu_frame(buf, len(data), sample) == -1
첫 번째 포스트에 적은 7바이트 파서 버그를 찾은 것이 이 테스트다. 3주 동안 못 잡던 버그였다.
전기 노이즈 때문에 SPI로 쓰레기 값이 들어올 때 문제가 되는 버그들인데, 사람은 테스트 케이스로 떠올리지도 못한다.
계층 2: 스펙 기반 테스트 (초, 타겟)
이 계층은 labgrid를 거쳐 실제 Raspberry Pi 4에서 돈다. 인수 기준 하나에 테스트 함수 하나씩이다.
# tests/test_imu_driver.py
import time
def test_sampling_rate_1khz(target):
"""AC-1: Sampling rate 1kHz within 1% tolerance."""
target.run("echo 1000 > /sys/class/imu/imu0/sampling_rate")
target.run("echo 0 > /sys/class/imu/imu0/sample_count")
time.sleep(10)
count = int(target.run("cat /sys/class/imu/imu0/sample_count"))
rate = count / 10.0
assert 990 <= rate <= 1010, f"Rate {rate} Hz outside 1% of 1000 Hz"
def test_dma_data_integrity(target):
"""AC-2: Data integrity after 10K DMA transfers."""
result = target.run("imu_integrity_test --transfers 10000 --verify crc32")
# imu_integrity_test is a small C program deployed to the target
lines = result.strip().split('\n')
last = lines[-1] # "PASS: 10000/10000 CRC match" or "FAIL: 9153/10000"
assert last.startswith("PASS"), f"Integrity check: {last}"
def test_spi_error_recovery(target):
"""AC-4: Recovery within 3s after SPI bus error."""
# Driver exposes force_error sysfs since spi-fault-inject is unavailable on kernel 6.1
target.run("echo 1 > /sys/class/imu/imu0/force_error")
time.sleep(0.5)
start = time.time()
for _ in range(30):
data = target.run("cat /sys/class/imu/imu0/data")
if "error" not in data.lower():
elapsed = time.time() - start
assert elapsed < 3.0, f"Recovery took {elapsed:.1f}s, limit 3s"
return
time.sleep(0.1)
raise AssertionError("Driver did not recover within 3s")
run_target_tests.sh 래퍼가 모듈을 올리고, 테스트를 모두 돌리고, JSON을 돌려준다. 에이전트가 SSH를 직접 다룰 일은 없다.
계층 3: 퍼징 (시간, 호스트)
SPI 프레임 파서를 위한 퍼즈 하네스다. AFL++ 인스트루먼테이션으로 컴파일한다.
/* tests/fuzz/harness_spi_parser.c */
#include <stdint.h>
#include <stdlib.h>
#include "imu.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
if (size > 256) return 0; /* limit input size */
imu_sample_t sample;
parse_imu_frame(data, (int)size, &sample);
return 0;
}
# Build and run
afl-clang-fast -o fuzz_parser tests/fuzz/harness_spi_parser.c drivers/imu/imu_spi.c -I drivers/imu/
afl-fuzz -i tests/fuzz/corpus -o findings -- ./fuzz_parser
코퍼스에는 정상 프레임, 잘린 프레임, 이미 알려진 불량 시퀀스를 시드로 넣어 둔다. AFL++는 CI에서 밤새 돈다. 첫 주에만 버그 두 개가 나왔다. 타임스탬프 파싱의 정수 오버플로, 그리고 특정 프레임 길이에서 CRC 체크가 실패할 때 생기는 use-after-free였다.
스펙 기반 테스트로는 이런 버그가 보이지 않는다. 사람이 손으로는 만들지 않을 특정한 바이트 패턴이 들어와야만 드러나기 때문이다.
계층 4: Hardware-in-the-Loop (분, 실제 하드웨어)
실제 하드웨어 테스트는 labgrid로 돌린다. CPU에 스트레스를 걸어 둔 상태의 DMA, 전원 사이클 뒤의 복구, 열 부하 아래의 지속 샘플링. 느리지만 타이밍과 주변장치 상호작용에서 생기는 버그를 잡는다.
# tests/test_imu_hil.py (runs via labgrid with power control)
def test_dma_under_cpu_stress(target, power):
"""AC-6: No data loss under CPU stress."""
target.run("stress-ng --cpu 4 --timeout 30 &")
target.run("echo 0 > /sys/class/imu/imu0/sample_count")
time.sleep(30)
count = int(target.run("cat /sys/class/imu/imu0/sample_count"))
expected = 30 * 1000 # 30s at 1kHz
loss = expected - count
assert loss == 0, f"Lost {loss} samples under stress ({count}/{expected})"
| 계층 | 잡는 버그 |
|---|---|
| 1. Property-based | 버퍼 오버플로, off-by-one, 인코딩과 디코딩의 불일치, 프로토콜 파싱의 엣지 케이스 |
| 2. 스펙 기반 | 인수 기준에 대한 회귀, 타겟에서만 나타나는 타이밍 문제, 실제 주변장치를 붙여야 드러나는 통합 문제 |
| 3. 퍼징 | 메모리 안전 버그, 정의되지 않은 동작, 크래시를 일으키는 입력 |
| 4. Hardware-in-the-Loop | 스트레스 아래의 타이밍과 주변장치 상호작용, 전원 사이클 뒤의 복구, 열의 영향 |
네 계층은 피라미드 모양이 된다. 계층 1은 코드가 바뀔 때마다 밀리초 단위로 돌고, 계층 2는 테스트 사이클마다 초 단위로 돈다. 계층 3은 밤새, 계층 4는 필요할 때나 주 단위로 돈다. 버그 대부분은 계층 1과 2에서 걸러진다. 비싼 계층은 거기서 빠져나간 것들을 줍는다.
CLAUDE.md: 남기는 것, 버리는 것
덩치 큰 CLAUDE.md는 결과를 낫게 하지도 못하면서 토큰만 쓴다(컨텍스트 엔지니어링 포스트에 이유를 적었다). 추론으로는 얻을 수 없는 내용만 그 자리에 있을 이유가 있다.
처음 내 CLAUDE.md는 58줄이었고, 그중 대부분이 낭비였다. 이런 식이었다.
## Project Structure
sensor-driver/ contains the IMU driver source code...
tests/ contains pytest-based tests using labgrid...
meta-sensor/ is the Yocto layer...
## Build
Uses meson build system. Cross-compile with:
meson setup build --cross-file cross-aarch64.ini
ninja -C build
## Testing
Run tests with: ./scripts/run_target_tests.sh build/imu_sensor.ko
에이전트는 이 내용을 모두 meson.build와 inventory.yaml, 폴더 구조에서 추론한다. 30줄이 넘는 내용이 아무 일도 하지 않는 셈이다.
정리하고 나니 22줄이 남았고, 군더더기가 없어졌다.
## Hardware
- SoC: i.MX8M Plus (Cortex-A53), SPI IMU: ICM-42688-P
- CTRL_REG1 = 0x4E (not 0x11). SPI mode 3 (CPOL=1, CPHA=1)
- DMA buffers: 64-byte aligned (L1 cache line)
## Learned Corrections
- 2026-01-15: ICM-42688-P CTRL_REG1 is 0x4E, not 0x11
- 2026-01-18: DMA buffers must be 64-byte aligned on Cortex-A53
- 2026-02-03: SPI mode 3 for ICM-42688-P, not mode 0
- 2026-02-22: Kernel 6.1 LTS lacks spi-fault-inject module
- 2026-03-01: spin_lock_bh() in process context, spin_lock() in softirq
## Never Do This
- kmalloc(GFP_KERNEL) or msleep under spin_lock
- CPU access to DMA buffer without dma_sync_single_for_cpu
- Assume register addresses from generic datasheets -- always check ICM-42688-P
한 줄 한 줄이 실제 버그에서 나왔다. 에이전트가 새로운 실수를 하면 파일이 늘고, 린터나 범위 규칙이 그 제약을 대신 지키기 시작하면 그만큼 줄어든다.
리뷰 에이전트
모든 리뷰어가 모든 변경에 도는 것은 아니다. 에이전트마다 시작할 때 파일 glob을 확인해서, 자기가 볼 것이 있는지부터 따진다.
| Reviewer | Triggers on | Instances |
|---|---|---|
| Concurrency | drivers/**/*.c, drivers/**/*.h | 2 (parallel) |
| Register contract | drivers/**/*.c, *.dts, *.dtsi | 2 (parallel) |
| Side-effect | any non-test file | 1 |
| Coding standard | drivers/**/*.c, drivers/**/*.h | 1 |
| Test coverage | tests/**/*.py, specs/**/*.md | 1 |
동시성 리뷰어와 레지스터 계약 리뷰어를 각각 2개씩 돌리는 이유는 컨텍스트 엔지니어링 포스트에 적었다. LLM이 한 번 보고 지나칠 때 놓친 것을, 같은 모델이 두 번째에는 잡아내는 경우가 있기 때문이다.
테스트만 고친 커밋은 테스트 커버리지 리뷰어 하나만 부른다. 디바이스 트리를 바꾸면 레지스터 계약 리뷰어가 뜨고 동시성 리뷰어는 건너뛴다. 대부분의 커밋은 드라이버 코드를 건드리기 때문에, 리뷰어 3개에서 4개, 인스턴스로는 5개에서 6개가 돈다. 결과는 감독자가 모두 모은다.
리뷰어 시스템 프롬프트는 모두 같은 틀을 따른다. 범위를 정하는 한 문장, 확인할 항목의 체크리스트, 그리고 범위 밖의 것은 무시하라는 분명한 지시.
동시성 리뷰어의 핵심 프롬프트는 이렇다.
You review ONLY concurrent execution safety. Ignore style, naming, performance.
## Checklist
- [ ] No spinlock held in sleepable context
- [ ] Correct lock variant for execution context
- [ ] DMA buffers synced before CPU access
- [ ] No shared state accessed without protection
- [ ] Lock ordering consistent across all paths
레지스터 계약 리뷰어는 이렇다.
You verify ONLY that hardware register accesses match the datasheet.
Reference: docs/hardware/imu-register-map.md
## Checklist
- [ ] Register addresses match ICM-42688-P datasheet
- [ ] Bit field masks and shifts correct
- [ ] Read/write direction matches register type
- [ ] Initialization sequence follows datasheet power-on requirements
- [ ] SPI mode, clock speed, and CS polarity correct
감독자는 인스턴스든 리뷰어든 2개 이상이 같은 이슈를 짚으면 높은 확신으로 보고, 에이전트가 스스로 고친다. 1개만 짚으면 중간 확신이다. 보고서에는 넣고 사람 리뷰가 필요하다는 플래그를 달지만, 자동으로 고치지는 않는다. 인스턴스 2개를 돌리는 핵심 리뷰어라면, 두 인스턴스가 같은 말을 하는 순간 이미 높은 확신이 된다.
리뷰 패스마다 그 앞에서 scripts/static_analysis.sh가 cppcheck와 clang-tidy를 돌려 JSON을 만든다. 이 JSON은 각 리뷰어 프롬프트에 추가 컨텍스트로 들어간다. 정적 분석 결과 위에 LLM 리뷰를 얹으면, 둘 중 하나만 쓸 때보다 더 많은 것이 걸린다.
전체 루프
사이클 한 번이 어떻게 흘러가는지 내 환경에서 시간을 재 봤다. 호스트는 Windows 노트북, 타겟은 RPi4이고 둘은 이더넷으로 연결했다.
| Step | Action | Time |
|---|---|---|
| 1 | 에이전트가 스펙 읽고 드라이버 코드 생성/수정 | ~30s |
| 2 | 크로스 컴파일 (aarch64, meson + ninja) | ~15s |
| 3 | 정적 분석 (cppcheck + clang-tidy to JSON) | ~10s |
| 4 | Property-based 테스트 (Hypothesis, 1000 examples) | ~3s |
| 5 | 배포 + 타겟 테스트 (run_target_tests.sh to JSON) | ~240s |
| 6 | 에이전트가 모든 결과 읽고 실패 수정 | ~30s |
| Total | ~5.5min |
3, 4단계는 호스트에서, 5단계는 타겟에서 돈다. Property-based 테스트나 정적 분석이 먼저 버그를 잡으면, 에이전트는 4분짜리 타겟 배포를 쓰기 전에 고친다. 나는 이 순서가 이 파이프라인에서 가장 중요하다고 본다. 빨리 실패하고, 싸게 실패하는 것.
에이전트의 수정이 테스트를 모두 통과하고 나서야 리뷰어가 돈다(동시 API 호출로 모두 합쳐 45초쯤). 어떤 리뷰어가 뜰지는 바뀐 파일에 따라 정해진다. 드라이버 코드를 건드리면 핵심 리뷰어 둘(각 2인스턴스)에 부작용 리뷰어와 코딩 표준 리뷰어가 붙는다. 테스트만 바꾸면 테스트 커버리지 리뷰어 하나로 끝난다. 감독자가 보고서를 낸다. 높은 확신 이슈는 자동으로 고치고 다시 테스트하고, 중간 확신 이슈는 플래그만 단다. 첫 패스에서는 보통 이슈가 1개에서 2개 걸리는데, 대개 락킹 규율이나 빠진 DMA 동기화다. 두 번째 반복쯤이면 대부분 깨끗하게 통과한다.
루프 전체, 그러니까 “자, 스펙이다”에서 “테스트 모두 통과, 리뷰어 모두 클리어”까지는 드라이버 기능 하나에 보통 2번에서 3번 반복하고 15분에서 20분이 걸린다. 첫 번째 포스트의 수동 워크플로와 견주면, 그쪽은 반복 한 번에 30분에서 60분이 들고, 그걸 3번에서 5번 되풀이하고도 정상 경로만 다룬다.
안 되는 것
이 파이프라인은 설계할 때 염두에 둔 케이스까지만 처리한다. 그 바깥에서는 할 수 있는 일이 금방 바닥난다.
형식 검증이 그렇다. Martin Kleppmann은 몇 년 안에 AI가 형식 검증을 주류로 끌어올릴 것이라고 예측한다. 하지만 아직은 범용 임베디드 드라이버에 쓰기에는 도구가 덜 여물었고, 지금 실용적으로 가장 비슷한 대안은 Property-based testing이다.
물리적 디버깅은 더 멀다. 로직 분석기에 SPI 클럭이 10MHz가 아니라 8MHz로 찍히거나, DMA 전송은 끝났는데 인터럽트가 뜨지 않을 때, 파이프라인은 할 수 있는 게 없다. 그건 오실로스코프가 맡을 일이다. 파이프라인이 책임지는 범위는 “코드가 스펙대로 맞다”까지다. 그 스펙이 물리적 현실과 맞는지는 여전히 사람이 판단해야 한다.
보안 회귀, 컨텍스트 저하, 스펙 품질은 컨텍스트 엔지니어링 포스트에서 길게 다뤘다. 줄여 말하면, 반복해서 고치다 보면 취약점이 슬그머니 들어올 수 있고(서브에이전트 리뷰어가 안전망이 된다), 에이전트는 2시간을 넘기면 방향을 잃기 시작하고(/clear로 끊어 준다), 스펙이 부실하면 파이프라인도 소용없다(정확한 인수 기준을 쓰는 일이 사람이 할 수 있는 가장 큰 투자다. TDD 포스트 참고).
시작하기
이 모두를 한꺼번에 갖출 필요는 없다. 계층마다 잡는 버그가 다르고, 어느 지점에서 멈춰도 괜찮다.
| Step | Action | Reference |
|---|---|---|
| 1 | 5개 인수 기준이 담긴 specs/<driver>.md | Post 1 |
| 2 | 테스트 래퍼 스크립트 (배포 + 테스트 + JSON) | Post 1 |
| 3 | 하드웨어 제약이 담긴 CLAUDE.md | Post 2 |
| 4 | 리뷰어 에이전트 하나 (동시성 또는 레지스터) | Post 2 |
| 5 | Property-based 테스트 + 정적 분석을 CI에 | 이 포스트 |
핵심은 에이전트가 아니다. 핵심은 피드백 루프다. 에이전트는 그 루프를 실제로 돌릴 수 있을 만큼 싸게 만들어 줄 뿐이다.
댓글
댓글 불러오는 중...