<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[kdy1: The way I think]]></title><description><![CDATA[kdy1: The way I think]]></description><link>https://kdy1.dev</link><generator>RSS for Node</generator><lastBuildDate>Wed, 11 Nov 2026 22:50:21 GMT</lastBuildDate><atom:link href="https://kdy1.dev/rss.xml" rel="self" type="application/rss+xml"/><language><![CDATA[en]]></language><ttl>60</ttl><item><title><![CDATA[작업 일지: 성능 관련 기여]]></title><description><![CDATA[일단 rspack, Lynx, Lynx의 기반이 되는 primjs를 대상으로 골랐다. rune에도 관심이 있었지만, GPU 기반이기도 하고 너무 초기 프로젝트 같아서 뒤로 미뤘다. 코드 변경은 전부 AI가 했다. 나는 최적화 방향을 생각하지는 않았고, 나온 변경이 옳은지만…]]></description><link>https://kdy1.dev/2026-10-24-performance-contribution-ko</link><guid isPermaLink="true">https://kdy1.dev/2026-10-24-performance-contribution-ko</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Fri, 23 Oct 2026 15:05:50 GMT</pubDate><content:encoded><![CDATA[<p>일단 <a href="https://rspack.rs/">rspack</a>, <a href="https://lynxjs.org/">Lynx</a>, Lynx의 기반이 되는 <a href="https://github.com/lynx-family/primjs">primjs</a>를 대상으로 골랐다. <a href="https://github.com/anomalyco/rune">rune</a>에도 관심이 있었지만, GPU 기반이기도 하고 너무 초기 프로젝트 같아서 뒤로 미뤘다.</p>
<p>코드 변경은 전부 AI가 했다. 나는 최적화 방향을 생각하지는 않았고, 나온 변경이 옳은지만 국소적으로 리뷰했다.</p>
<p>셋 다 내 계정으로 포크하고, AI로 각 저장소에 Gungraun 기반 최적화 스킬을 구성했다. 포크의 CI에서 측정하고, 내 승인을 받은 변경만 원본 저장소에 PR로 보내도록 했다.</p>
<ul>
<li><a href="https://github.com/kdy1/rspack/pull/3">rspack 설정</a></li>
<li><a href="https://github.com/kdy1/lynx/pull/1">Lynx 설정</a></li>
<li><a href="https://github.com/kdy1/primjs/pull/1">primjs 설정</a></li>
</ul>
<p>결과물을 보니 벤치마크가 다 mock이었다. 프롬프트가 너무 단순했는지도 모르겠다. 그래서 모든 코드를 프로파일링할 수 있도록 다시 시켰다.</p>
<blockquote>
<p>일단 내 포크의 Gungraun CI를 모든 걸 프로파일링 할 수 있도록 고치자</p>
</blockquote>
<p>셋 다 병렬로 돌렸지만 실제 검증까지 포함이라 시간이 조금 걸렸다. primjs는 <a href="https://github.com/kdy1/primjs/pull/2">함수 이름과 호출 비용을 확인하고, 다른 JavaScript 파일도 워크로드로 넣을 수 있도록 수정됐다</a>.</p>
<p>primjs에 <a href="https://github.com/lynx-family/primjs/pull/439">첫 PR</a>을 만들었다. 정수의 후위 증가·감소 연산에서 불필요한 변환을 줄이는 변경이었다.</p>
<p>AI를 활용해서 성능 최적화를 해도 괜찮은지 묻는 <a href="https://github.com/lynx-family/primjs/pull/439#issuecomment-6361629024">댓글</a>도 남겼다. 거의 모든 작업에 AI를 쓰되, 보내는 PR은 전부 검증하겠다고 했다.</p>
<p>첫 PR을 보고 이 방식이 작동한다는 확신이 생겨서, 이런 기여를 받고 싶은 프로젝트가 더 있는지 <a href="https://x.com/kdy1dev/status/2113562240586756275">X에 물어봤다</a>. rspack 팀에도 AI로 성능에 대량으로 기여해도 되는지 물어봤고 승인을 받았다.</p>
<p>이 방식은 AI가 벤치마크 데이터에서 더 이상 문제를 찾지 못할 때까지 PR이 나온다. 각 PR은 깔끔하게 분리되지만 수가 많아지기 때문에, 유용한 PR을 엄청나게 많이 보내도 괜찮은지 미리 물어본 것이다.</p>
<p>잠깐 뒤에 primjs의 <a href="https://github.com/lynx-family/primjs/pull/443">두 번째 PR</a>도 만들어졌다. 정수를 문자열로 변환할 때 기존 포매터를 재사용하는 변경이었다. PR 생성 전에 내가 변경사항을 직접 리뷰했고, 혹시 몰라 T3 Code로 보안 리뷰도 돌렸다.</p>
<blockquote>
<p><a href="https://github.com/lynx-family/primjs/pull/443">https://github.com/lynx-family/primjs/pull/443</a> 가 보안상 문제가 될 수 있는지 리뷰해줘</p>
</blockquote>
<p>그다음 rspack의 프로파일링 환경도 준비됐다. <a href="https://github.com/kdy1/rspack/pull/4">기존 Rust 벤치마크 59개를 측정할 수 있도록 수정됐다</a>.</p>
<p>바로 최적화를 돌렸다. rspack은 워낙 커서 프롬프트에 병렬 테스트를 추가했다.</p>
<blockquote>
<p>$gungraun-optimize 일단 프로파일링 하고, 서브에이전트로 각 최적화 아이디어를 병렬로 테스트해줘. 한번에 최대 5개까지 해주면 돼</p>
</blockquote>
<p>스킬이 잘 작동하는 것 같아서 여러 프로젝트에서 쓸 수 있도록 <a href="https://github.com/kdy1/kdy1-scripts/tree/8f1f49a3cee8e15357923817a4267723c0890a6b/skills/fork-gungraun-optimize">공통화했다</a>. 그리고 <a href="https://github.com/ada-url/ada">ada</a>에도 시도해 보려고 <a href="https://github.com/kdy1/ada">포크했다</a>.</p>
<p>primjs의 <a href="https://github.com/lynx-family/primjs/pull/444">세 번째 PR</a>은 문자열 처리 중 힙 할당을 줄이는 변경이었다. 직접 리뷰해 보니 diff가 작고 범위가 명확해서 PR 생성을 승인했다.</p>
<p>다만 아직 Lynx 팀의 승인을 받은 것은 아니라, primjs와 Lynx에는 더 보내지 않고 이미 만든 세 개가 머지될 때까지 기다리기로 했다.</p>
<p>ada에도 <a href="https://github.com/ada-url/ada/pull/1334">첫 PR</a>을 만들었다. 경로 인코딩 중 임시 버퍼를 없애는 변경이었다. <a href="https://github.com/ada-url/ada/pull/1335">두 번째 PR</a>은 IPv6 주소를 문자열로 만들 때 불필요한 할당을 줄이는 변경이었고, diff가 작아서 리뷰하기 쉬웠다.</p>
<p>도메인 검증을 제거하는 변경도 나왔지만, 이게 옳은지 모르겠어서 PR 생성을 승인하지 않았다. <a href="https://github.com/kdy1/ada/commit/733effea3ae0d91fd5b93111e4c8bef3da7ae91d">커밋은 포크에 남아 있다</a>.</p>
<p>그다음에는 <a href="https://github.com/ada-url/ada/pull/1336">문자열 검색을 단순화하는 PR</a>을 하나 더 만들었다. 리뷰해 보니 변경이 깔끔했고, 모든 측정 케이스에서 명령어 수가 같거나 줄어서 승인했다.</p>
<p>잠깐 놀다가 왔더니 ada의 <a href="https://github.com/ada-url/ada/pull/1335">#1335</a>가 머지돼 있었다.</p>
<p>다른 두 PR에는 Codspeed에서 리그레션이 표시됐다. 확인해 보니 느려졌다고 나온 벤치마크는 변경한 경로를 실행하지 않았고, 서로 다른 종류의 러너에서 비교됐다는 경고도 있었다. 각각 <a href="https://github.com/ada-url/ada/pull/1334#issuecomment-6366186045">댓글</a>을 <a href="https://github.com/ada-url/ada/pull/1336#issuecomment-6366189700">남겼다</a>. 보기에도 관련 없어 보였지만 확실히 하려고 AI로도 한 번 더 검증했다.</p>
<p>rspack 쪽에서는 swc-next를 수정할 필요가 있어서 <a href="https://github.com/swc-project/swc-next/pull/1116">PR</a>을 만들었다. SIMD 마스크 변환에서 불필요한 연산을 줄이는 변경이었다.</p>
<p>스킬의 성능 기준은 1%인데, rspack 같은 프로젝트에서 국소적인 최적화로 전체가 1% 개선되길 바라는 건 지나친 욕심 같았다. 그래서 후보를 각각 다시 물어보라고 했다.</p>
<p>그 뒤 rspack에 <a href="https://github.com/web-infra-dev/rspack/pull/16223">경로 처리 중 불필요한 문자열 검색을 피하는 PR</a>과 <a href="https://github.com/web-infra-dev/rspack/pull/16224">작은 export 목록의 조회 방식을 바꾸는 PR</a>을 만들었다.</p>
]]></content:encoded></item><item><title><![CDATA[Task Log: Performance Contribution ]]></title><description><![CDATA[I started with Rspack, Lynx, and PrimJS, which Lynx is built on. I was also interested in Rune, but put it off because it was GPU-based and seemed too…]]></description><link>https://kdy1.dev/2026-10-24-performance-contribution</link><guid isPermaLink="true">https://kdy1.dev/2026-10-24-performance-contribution</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Fri, 23 Oct 2026 15:05:21 GMT</pubDate><content:encoded><![CDATA[<p>I started with <a href="https://rspack.rs/">Rspack</a>, <a href="https://lynxjs.org/">Lynx</a>, and <a href="https://github.com/lynx-family/primjs">PrimJS</a>, which Lynx is built on. I was also interested in <a href="https://github.com/anomalyco/rune">Rune</a>, but put it off because it was GPU-based and seemed too early-stage.</p>
<p>AI made all the code changes. I didn’t think through the optimization strategy myself. I reviewed the resulting changes locally for correctness.</p>
<p>I forked all three under my account and had AI set up a Gungraun-based optimization skill in each repository. Measurements would run in the fork’s CI, and changes would only be submitted upstream after my approval.</p>
<ul>
<li><a href="https://github.com/kdy1/rspack/pull/3">Rspack setup</a></li>
<li><a href="https://github.com/kdy1/lynx/pull/1">Lynx setup</a></li>
<li><a href="https://github.com/kdy1/primjs/pull/1">PrimJS setup</a></li>
</ul>
<p>When I looked at the results, the benchmarks were all mocks. Maybe my prompt had been too simple. So I asked it to make all the code available for profiling.</p>
<blockquote>
<p>First, fix the Gungraun CI in my fork so it can profile everything.</p>
</blockquote>
<p>I ran this for all three projects in parallel, but it took a while because the work included actual verification. For PrimJS, <a href="https://github.com/kdy1/primjs/pull/2">the setup was updated to show function names and call costs, and accept other JavaScript files as workloads</a>.</p>
<p>I submitted the <a href="https://github.com/lynx-family/primjs/pull/439">first PrimJS PR</a>. It reduced unnecessary conversions in integer postfix increment and decrement operations.</p>
<p>I also left a <a href="https://github.com/lynx-family/primjs/pull/439#issuecomment-6361629024">comment</a> asking whether AI-assisted performance contributions would be welcome. I said I would use AI for almost everything, but verify every PR I sent.</p>
<p>The first PR convinced me that this approach worked, so I <a href="https://x.com/kdy1dev/status/2113562240586756275">asked on X</a> whether any other projects wanted contributions like these. I also asked the Rspack team whether a large number of AI-assisted performance contributions would be welcome, and they agreed.</p>
<p>With this approach, PRs keep coming until AI can no longer find problems in the benchmark data. Each PR is focused, but there can be a lot of them. That was why I asked beforehand whether sending a huge number of useful PRs would be okay.</p>
<p>A little later, the <a href="https://github.com/lynx-family/primjs/pull/443">second PrimJS PR</a> was ready. It reused an existing formatter for integer-to-string conversion. I personally reviewed the changes before approving PR creation. Just in case, I also ran a security review in T3 Code.</p>
<blockquote>
<p>Review whether <a href="https://github.com/lynx-family/primjs/pull/443">https://github.com/lynx-family/primjs/pull/443</a> could introduce any security issues.</p>
</blockquote>
<p>The Rspack profiling setup was ready next. <a href="https://github.com/kdy1/rspack/pull/4">It had been extended to measure 59 existing Rust benchmark cases</a>.</p>
<p>I started the optimization run right away. Since Rspack is a large project, I added parallel testing to the prompt.</p>
<blockquote>
<p>$gungraun-optimize First, profile the code, then use subagents to test each optimization idea in parallel. Run up to five at a time.</p>
</blockquote>
<p>The skill seemed to work well, so I <a href="https://github.com/kdy1/kdy1-scripts/tree/8f1f49a3cee8e15357923817a4267723c0890a6b/skills/fork-gungraun-optimize">generalized it for use across projects</a>. Then I <a href="https://github.com/kdy1/ada">forked Ada</a> to try it on <a href="https://github.com/ada-url/ada">ada-url/ada</a> too.</p>
<p>The <a href="https://github.com/lynx-family/primjs/pull/444">third PrimJS PR</a> reduced heap allocations during string processing. I reviewed it, found the diff small and well scoped, and approved PR creation.</p>
<p>I still hadn’t received approval from the Lynx team, though. I decided to stop sending PRs to PrimJS and Lynx and wait for the three existing PRs to merge.</p>
<p>I submitted the <a href="https://github.com/ada-url/ada/pull/1334">first Ada PR</a>, which removed a temporary buffer during path encoding. The <a href="https://github.com/ada-url/ada/pull/1335">second PR</a> reduced unnecessary allocation when converting IPv6 addresses to strings. Its small diff made it easy to review.</p>
<p>Another candidate removed domain validation, but I couldn’t tell whether that was correct, so I didn’t approve a PR for it. <a href="https://github.com/kdy1/ada/commit/733effea3ae0d91fd5b93111e4c8bef3da7ae91d">The commit is still in my fork</a>.</p>
<p>Next came <a href="https://github.com/ada-url/ada/pull/1336">a PR simplifying string searches</a>. The change looked clean when I reviewed it, and instruction counts were unchanged or lower in every measured case, so I approved it.</p>
<p>I went off to relax for a bit. When I came back, Ada <a href="https://github.com/ada-url/ada/pull/1335">#1335</a> had merged.</p>
<p>CodSpeed reported regressions on the other two PRs. On inspection, the benchmarks flagged as slower didn’t execute the changed code paths. There was also a warning that the comparisons used different runner types. I left comments on <a href="https://github.com/ada-url/ada/pull/1334#issuecomment-6366186045">both</a> <a href="https://github.com/ada-url/ada/pull/1336#issuecomment-6366189700">PRs</a>. They looked unrelated to the changes, but I also had AI double-check.</p>
<p>On the Rspack side, a change to swc-next was needed, so I submitted <a href="https://github.com/swc-project/swc-next/pull/1116">a PR there</a>. It reduced unnecessary operations in SIMD mask conversions.</p>
<p>The skill’s performance threshold was 1%, but expecting a local optimization to improve an entire project like Rspack by 1% seemed like asking too much. So I told it to ask me about each candidate again.</p>
<p>After that, I submitted two Rspack PRs: <a href="https://github.com/web-infra-dev/rspack/pull/16223">one avoiding unnecessary string searches during path processing</a>, and <a href="https://github.com/web-infra-dev/rspack/pull/16224">one changing how small export lists are searched</a>.</p>
]]></content:encoded></item><item><title><![CDATA[코덱스 구독의 토큰 속도]]></title><description><![CDATA[구독 사용량을 고려하면 Astra를 주력으로 쓰기는 어렵다. 그런데 gpt-6.1-sol도 예상보다 느리게 느껴졌다. 그래서 같은 작업을 여러 모델에 맡기고, 세션 로그를 바탕으로 토큰 생성 속도를 비교해 봤다. 모든 모델에 아래 프롬프트를 그대로 사용했다. 도구 사용과 파일…]]></description><link>https://kdy1.dev/2026-10-14-codex-subscription-token-rate-ko</link><guid isPermaLink="true">https://kdy1.dev/2026-10-14-codex-subscription-token-rate-ko</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Wed, 14 Oct 2026 01:28:32 GMT</pubDate><content:encoded><![CDATA[<p>구독 사용량을 고려하면 Astra를 주력으로 쓰기는 어렵다. 그런데 <code>gpt-6.1-sol</code>도 예상보다 느리게 느껴졌다. 그래서 같은 작업을 여러 모델에 맡기고, 세션 로그를 바탕으로 토큰 생성 속도를 비교해 봤다.</p>
<h3>측정 방법</h3>
<p>모든 모델에 아래 프롬프트를 그대로 사용했다. 도구 사용과 파일 작업을 막고, 분산 작업 큐의 실패 상황에 관한 테스트 사례 120개를 영어로 작성하도록 했다.</p>
<blockquote>
<p>This is a controlled model-speed benchmark. Do not use any tools, do not inspect the repository, and do not modify files. Produce exactly 120 numbered items describing distinct failure-mode test cases for a distributed job queue. Each item must be exactly one English sentence of 18 to 28 words and must include: the triggering condition, the expected behavior, and one observable assertion. Do not add an introduction, conclusion, headings, or any text outside the 120 numbered items.</p>
</blockquote>
<p>여기서 <strong>TTFT</strong>는 첫 토큰까지 걸린 시간이다. <strong>표시 생성 속도</strong>는 다음 식으로 계산했다.</p>
<p><code>(output_tokens − reasoning_output_tokens) ÷ (완료시간 − TTFT)</code></p>
<p>따라서 표의 tok/s는 요청부터 완료까지의 전체 처리량이 아니라, 첫 토큰 이후 사용자에게 표시되는 토큰의 평균 생성 속도다.</p>
<h3>Sol · medium</h3>
<table>
<thead>
<tr>
<th>모델</th>
<th>TTFT</th>
<th>완료시간</th>
<th>표시 토큰</th>
<th>표시 생성 속도</th>
</tr>
</thead>
<tbody><tr>
<td><code>gpt-6-sol</code></td>
<td>6.759초</td>
<td>41.635초</td>
<td>3,199</td>
<td><strong>91.72 tok/s</strong></td>
</tr>
<tr>
<td><code>gpt-5.6-sol</code></td>
<td><strong>6.199초</strong></td>
<td>42.811초</td>
<td>3,162</td>
<td>86.37 tok/s</td>
</tr>
<tr>
<td><code>gpt-6.1-sol</code></td>
<td>7.038초</td>
<td>80.531초</td>
<td>3,236</td>
<td>44.03 tok/s</td>
</tr>
</tbody></table>
<p>이번 <code>medium</code> 실행에서 <code>gpt-6-sol</code>의 표시 생성 속도는 <code>gpt-6.1-sol</code>의 약 2.08배였다. 첫 토큰은 <code>gpt-5.6-sol</code>이 가장 빨랐지만, 전체 작업을 가장 먼저 마친 모델은 <code>gpt-6-sol</code>이었다. 처음에 <code>gpt-6.1-sol</code>을 느리게 느꼈던 것과도 맞닿는 결과다. 다만 이 수치는 이번 작업의 한 번의 실행에서 나온 값이다.</p>
<h3>Sol · high</h3>
<table>
<thead>
<tr>
<th>모델</th>
<th>TTFT</th>
<th>완료시간</th>
<th>표시 토큰</th>
<th>표시 생성 속도</th>
</tr>
</thead>
<tbody><tr>
<td><code>gpt-6-sol</code></td>
<td>8.116초</td>
<td>42.870초</td>
<td>3,233</td>
<td><strong>93.03 tok/s</strong></td>
</tr>
<tr>
<td><code>gpt-5.6-sol</code></td>
<td><strong>7.063초</strong></td>
<td><strong>41.916초</strong></td>
<td>3,094</td>
<td>88.77 tok/s</td>
</tr>
<tr>
<td><code>gpt-6.1-sol</code></td>
<td>9.675초</td>
<td>82.776초</td>
<td>3,330</td>
<td>45.55 tok/s</td>
</tr>
</tbody></table>
<p><code>high</code>에서도 표시 생성 속도 순서는 같았다. <code>gpt-6-sol</code>이 가장 빠르게 토큰을 생성했고, <code>gpt-6.1-sol</code>은 약 절반 수준이었다. 반면 완료시간은 <code>gpt-5.6-sol</code>이 41.916초로 가장 짧았다. 생성 속도와 작업 완료시간을 구분해서 볼 필요가 있는 대목이다.</p>
<p>각 Sol 모델의 표시 생성 속도는 <code>medium</code>에서 <code>high</code>로 바꿔도 이번 측정에서는 큰 차이가 없었다. TTFT는 세 모델 모두 늘었다. 다만 <code>gpt-5.6-sol high</code> 실행에는 입력 캐시가 적용되지 않았으므로, 설정에 따른 TTFT 변화만 따로 떼어 해석하기는 어렵다.</p>
<h3>Luna · xhigh</h3>
<table>
<thead>
<tr>
<th>모델</th>
<th>TTFT</th>
<th>완료시간</th>
<th>표시 토큰</th>
<th>Reasoning 토큰</th>
<th>표시 생성 속도</th>
</tr>
</thead>
<tbody><tr>
<td><code>gpt-5.6-luna</code></td>
<td><strong>4.739초</strong></td>
<td><strong>37.084초</strong></td>
<td>2,922</td>
<td>1,396</td>
<td><strong>90.34 tok/s</strong></td>
</tr>
<tr>
<td><code>gpt-6-luna</code></td>
<td>8.298초</td>
<td>63.097초</td>
<td>3,258</td>
<td>4,870</td>
<td>59.45 tok/s</td>
</tr>
</tbody></table>
<p>이번 <code>xhigh</code> 측정에서는 <code>gpt-5.6-luna</code>가 표시 생성 속도에서 약 1.52배 빨랐고, 완료시간도 짧았다. <code>gpt-6-luna</code>의 Reasoning 토큰은 4,870개로 <code>gpt-5.6-luna</code>의 1,396개보다 많았다. 두 모델의 출력 과정이 달랐다는 점을 보여주는 수치지만, 이 한 번의 측정만으로 완료시간 차이의 원인을 단정할 수는 없다.</p>
<p><code>gpt-5.6-luna</code>의 첫 실행은 29.273초에 끝났으나 토큰 계산에 필요한 JSONL 로그가 생성되지 않았다. 위 표에는 로그를 확보한 단독 재실행 결과인 37.084초를 사용했다.</p>
<h3>실험의 한계</h3>
<p>각 설정은 단일 실행 결과다. 순간적인 서버 상태나 실행 조건에 따라 수치가 달라질 수 있으므로, 이 표를 모델의 고정된 속도로 받아들이기는 어렵다. 특히 Luna 표의 두 값은 <code>gpt-5.6-luna</code> 재실행 때문에 동일한 동시 실행 한 쌍의 결과가 아니다.</p>
<p>이번 프롬프트는 120개 항목을 길게 출력하는 작업이었다. 측정 결과는 그 작업에서의 응답 속도를 보여준다. 다른 길이와 종류의 작업에서도 순서가 같을지, 생성된 내용의 품질은 어떤지는 이 측정으로 판단하지 않았다.</p>
]]></content:encoded></item><item><title><![CDATA[Codex Subscription Token Rate]]></title><description><![CDATA[Given my subscription usage, Astra is difficult to use as my main model. But GPT-6.1 Sol also felt slower than I expected, so I ran a small comparison. I…]]></description><link>https://kdy1.dev/2026-10-14-codex-subscription-token-rate</link><guid isPermaLink="true">https://kdy1.dev/2026-10-14-codex-subscription-token-rate</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Wed, 14 Oct 2026 01:28:23 GMT</pubDate><content:encoded><![CDATA[<p>Given my subscription usage, Astra is difficult to use as my main model. But GPT-6.1 Sol also felt slower than I expected, so I ran a small comparison. I gave several models the same task and calculated their token generation speeds from the session logs.</p>
<h2>How I measured it</h2>
<p>I used the same prompt for every run:</p>
<blockquote>
<p>This is a controlled model-speed benchmark. Do not use any tools, do not inspect the repository, and do not modify files. Produce exactly 120 numbered items describing distinct failure-mode test cases for a distributed job queue. Each item must be exactly one English sentence of 18 to 28 words and must include: the triggering condition, the expected behavior, and one observable assertion. Do not add an introduction, conclusion, headings, or any text outside the 120 numbered items.</p>
</blockquote>
<p><strong>TTFT</strong> is the time to the first token. I calculated the rate of visible token generation as:</p>
<p><code>(output tokens − reasoning output tokens) ÷ (completion time − TTFT)</code></p>
<p>This rate describes the average speed of visible output after the first token. It is different from output tokens divided by the full completion time.</p>
<h2>Sol at medium effort</h2>
<table>
<thead>
<tr>
<th>Model</th>
<th>TTFT</th>
<th>Completion time</th>
<th>Visible tokens</th>
<th>Visible generation rate</th>
</tr>
</thead>
<tbody><tr>
<td><code>gpt-6-sol</code></td>
<td>6.759 s</td>
<td>41.635 s</td>
<td>3,199</td>
<td><strong>91.72 tok/s</strong></td>
</tr>
<tr>
<td><code>gpt-5.6-sol</code></td>
<td><strong>6.199 s</strong></td>
<td>42.811 s</td>
<td>3,162</td>
<td>86.37 tok/s</td>
</tr>
<tr>
<td><code>gpt-6.1-sol</code></td>
<td>7.038 s</td>
<td>80.531 s</td>
<td>3,236</td>
<td>44.03 tok/s</td>
</tr>
</tbody></table>
<p>In this run, <code>gpt-6-sol</code> generated visible tokens about 2.08 times as fast as <code>gpt-6.1-sol</code>. <code>gpt-5.6-sol</code> produced the first token soonest, while <code>gpt-6-sol</code> finished the task first. The <code>gpt-6.1-sol</code> result was consistent with my impression that it felt slow, though it is only one run of one task.</p>
<h2>Sol at high effort</h2>
<table>
<thead>
<tr>
<th>Model</th>
<th>TTFT</th>
<th>Completion time</th>
<th>Visible tokens</th>
<th>Visible generation rate</th>
</tr>
</thead>
<tbody><tr>
<td><code>gpt-6-sol</code></td>
<td>8.116 s</td>
<td>42.870 s</td>
<td>3,233</td>
<td><strong>93.03 tok/s</strong></td>
</tr>
<tr>
<td><code>gpt-5.6-sol</code></td>
<td><strong>7.063 s</strong></td>
<td><strong>41.916 s</strong></td>
<td>3,094</td>
<td>88.77 tok/s</td>
</tr>
<tr>
<td><code>gpt-6.1-sol</code></td>
<td>9.675 s</td>
<td>82.776 s</td>
<td>3,330</td>
<td>45.55 tok/s</td>
</tr>
</tbody></table>
<p>The ranking by visible generation rate was the same at high effort: <code>gpt-6-sol</code> was fastest, and <code>gpt-6.1-sol</code> ran at roughly half its rate. Yet <code>gpt-5.6-sol</code> had the shortest completion time, at 41.916 seconds. Generation rate and time to finish the whole task tell slightly different stories.</p>
<p>For each Sol model, the visible generation rate changed little between medium and high effort in these runs. TTFT increased for all three. Input caching was not applied to the <code>gpt-5.6-sol</code> high-effort run, however, so the TTFT difference cannot be attributed solely to the effort setting.</p>
<h2>Luna at xhigh effort</h2>
<table>
<thead>
<tr>
<th>Model</th>
<th>TTFT</th>
<th>Completion time</th>
<th>Visible tokens</th>
<th>Reasoning tokens</th>
<th>Visible generation rate</th>
</tr>
</thead>
<tbody><tr>
<td><code>gpt-5.6-luna</code></td>
<td><strong>4.739 s</strong></td>
<td><strong>37.084 s</strong></td>
<td>2,922</td>
<td>1,396</td>
<td><strong>90.34 tok/s</strong></td>
</tr>
<tr>
<td><code>gpt-6-luna</code></td>
<td>8.298 s</td>
<td>63.097 s</td>
<td>3,258</td>
<td>4,870</td>
<td>59.45 tok/s</td>
</tr>
</tbody></table>
<p>In these measurements, <code>gpt-5.6-luna</code> generated visible tokens about 1.52 times as fast and finished sooner. <code>gpt-6-luna</code> used 4,870 reasoning tokens, compared with 1,396 for <code>gpt-5.6-luna</code>. That shows a difference in their recorded output, but this single measurement does not establish how much of the completion-time gap it caused.</p>
<p>The first <code>gpt-5.6-luna</code> run finished in 29.273 seconds, but it did not produce the JSONL log needed to calculate its token rate. The table uses a separate run that finished in 37.084 seconds and had a usable log.</p>
<h2>Limits of this comparison</h2>
<p>Each reported configuration has one logged measurement. Temporary server conditions and other differences between runs could affect the results, so these numbers should not be treated as fixed speeds. The Luna table also combines <code>gpt-6-luna</code> with a separate rerun of <code>gpt-5.6-luna</code>, rather than two results from the same simultaneous pair.</p>
<p>The prompt asked for a long output of 120 items. These results describe response speed on that task. They do not show whether the ranking would hold for other tasks or output lengths, and they do not evaluate the quality of the generated test cases.</p>
]]></content:encoded></item><item><title><![CDATA[AI로 UI 작업하는 내 방식]]></title><description><![CDATA[AI로 UI 작업하기 힘들다는 사람이 많아서, 내가 작업하는 방식을 짧게 공유한다. 나는 다음 순서로 작업한다. $design-ui로 AI가 imagegen을 써서 시안을 만들고, 내 승인을 받는다. $add-issue로 승인한 시안과 프롬프트를 이슈에 첨부한다…]]></description><link>https://kdy1.dev/2026-10-12-ai-ui-ko</link><guid isPermaLink="true">https://kdy1.dev/2026-10-12-ai-ui-ko</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Mon, 12 Oct 2026 02:20:58 GMT</pubDate><content:encoded><![CDATA[<p>AI로 UI 작업하기 힘들다는 사람이 많아서, 내가 작업하는 방식을 짧게 공유한다.</p>
<p>나는 다음 순서로 작업한다.</p>
<ol>
<li><p><code>$design-ui</code>로 AI가 imagegen을 써서 시안을 만들고, 내 승인을 받는다.</p>
</li>
<li><p><code>$add-issue</code>로 승인한 시안과 프롬프트를 이슈에 첨부한다.</p>
</li>
<li><p><code>$slop-fix-batch</code>로 병렬 구현한다.</p>
</li>
</ol>
<img src="https://cdn.hashnode.com/uploads/covers/64c9efa7b925449e35ee2318/98a15a69-2f16-4695-a10c-729366b82c0c.png" alt="" style="display:block;margin:0 auto" />

<p>첨부한 스크린샷은 AI가 imagegen으로 만든 시안을 보여주고 승인을 요청하는 예시다. 이때 내가 입력한 프롬프트는 다음과 같다.</p>
<blockquote>
<p>DeliDev의 각 화면에 적절한 애니메이션을 넣고 싶어. 화면별로 $add-issue</p>
</blockquote>
<p>스킬은 <a href="https://github.com/kdy1/kdy1-scripts">kdy1/kdy1-scripts</a>에 있다. <code>$add-issue</code>와 <code>$design-ui</code>가 사용된 실제 이슈는 <a href="https://github.com/delinoio/oss/issues/2789">여기</a>에서 볼 수 있다. 스크린샷은 한국어다.</p>
<p>참고로 나는 별도 리뷰 없이 메인에 머지한다.</p>
]]></content:encoded></item><item><title><![CDATA[How I Build UIs with AI]]></title><description><![CDATA[A lot of people say UI work is difficult with AI, so I wanted to briefly share how I do it. My workflow is: With $design-ui, the AI uses imagegen to create…]]></description><link>https://kdy1.dev/2026-10-12-ai-ui</link><guid isPermaLink="true">https://kdy1.dev/2026-10-12-ai-ui</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Mon, 12 Oct 2026 02:20:55 GMT</pubDate><content:encoded><![CDATA[<p>A lot of people say UI work is difficult with AI, so I wanted to briefly share how I do it.</p>
<p><img src="align=%22center%22" alt="" /></p>
<p>My workflow is:</p>
<ol>
<li><p>With <code>$design-ui</code>, the AI uses imagegen to create a mockup and asks for my approval.</p>
</li>
<li><p>With <code>$add-issue</code>, it attaches the approved mockup and prompt to an issue.</p>
</li>
<li><p>With <code>$slop-fix-batch</code>, it implements the issues in parallel.</p>
</li>
</ol>
<img src="https://cdn.hashnode.com/uploads/covers/64c9efa7b925449e35ee2318/e864c9c4-a074-4e75-81b8-68db4f817b00.png" alt="" style="display:block;margin:0 auto" />

<p>The attached screenshot shows the AI presenting an imagegen mockup and asking for approval. Here’s the prompt I used, translated from Korean:</p>
<blockquote>
<p>I want to add appropriate animations to each screen in DeliDev. For each screen, $add-issue</p>
</blockquote>
<p>The skills are in <a href="https://github.com/kdy1/kdy1-scripts">kdy1/kdy1-scripts</a>. You can see an actual issue created using <code>$add-issue</code> and <code>$design-ui</code> <a href="https://github.com/delinoio/oss/issues/2789">here</a>. The screenshots are in Korean.</p>
<p>For context, I merge into main without a separate review.</p>
]]></content:encoded></item><item><title><![CDATA[AI 워크플로우 업데이트]]></title><description><![CDATA[지난 글에서는 Labor0와 Codex로 수십 개의 작업을 병렬로 처리하는 워크플로우를 소개했다. 그 이후로도 내 개발 방식은 계속 바뀌었다. 지금은 Labor0를 쓰지 않고, 공개해 둔 스킬들을 활용하고 있다. 이번에 해결한 문제는 PR을 많이 만든 다음에 생기는 병목이다…]]></description><link>https://kdy1.dev/2026-10-8-ai-workflow-update-ko</link><guid isPermaLink="true">https://kdy1.dev/2026-10-8-ai-workflow-update-ko</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Thu, 08 Oct 2026 01:58:25 GMT</pubDate><content:encoded><![CDATA[<p><a href="https://kdy1.dev/2026-9-6-humans-are-always-the-bottleneck">지난 글</a>에서는 Labor0와 Codex로 수십 개의 작업을 병렬로 처리하는 워크플로우를 소개했다. 그 이후로도 내 개발 방식은 계속 바뀌었다. 지금은 Labor0를 쓰지 않고, 공개해 둔 스킬들을 활용하고 있다.</p>
<p>이번에 해결한 문제는 PR을 많이 만든 다음에 생기는 병목이다. PR을 만드는 것까지는 쉬운데, 그걸 전부 머지하는 데 시간이 너무 오래 걸렸다.</p>
<h2>이슈 트래커를 프롬프트 저장소로 쓰기</h2>
<p>나는 구체적인 이슈를 남기기 위해 항상 <code>$add-issue</code> 스킬을 사용한다. 이슈 트래커를 일종의 프롬프트 저장소처럼 쓰는 셈이다.</p>
<p>발상은 단순하다. 구체적인 이슈들을 미리 만들어 두면, 그것들을 병렬로 처리하는 건 쉽다. 무엇을 해야 하는지가 이슈에 들어 있으니, 나중에는 처리할 이슈들을 지정해서 실행하면 된다.</p>
<p>그런데 작업을 엄청나게 많이 처리하다 보니 다른 문제가 생겼다. PR이 30개쯤 쌓이면 머지 충돌이 계속 발생했다. 충돌을 해결하고 리베이스하는 데 너무 오래 걸렸다.</p>
<p>Labor0는 의존성 분석으로 이 문제를 해결해 줬지만, 나는 더 이상 Labor0를 쓰지 않는다. 처음에는 Codex에서 세션을 병렬로 만들어 해결하려고 했다. 하지만 그렇게 만들어진 PR들을 모두 머지하는 일은 여전히 오래 걸렸다.</p>
<p>최근에는 Stacked PR이 더 낫다는 걸 깨달았고, 이 방식을 스킬로 만들어 쓰고 있다.</p>
<h2>이슈 수십 개를 Stacked PR로 만들기</h2>
<p>지금은 스킬로 이슈 수십 개를 만들어 둔 뒤, 라벨 등으로 대상을 지정해서 <code>$slop-fix-batch</code>를 한 번 실행한다. 그러면 스킬이 이슈들을 처리하고 Stacked PR을 만들어 준다.</p>
<p>오픈소스 저장소인 <a href="https://github.com/delinoio/oss">delinoio/oss</a>에서는 이런 식으로 호출한다.</p>
<pre><code class="language-text">$slop-fix-batch sort:updated-desc is:issue state:open label:slop-batch author:kdy1
</code></pre>
<p>스킬이 PR을 만들었다고 바로 끝나는 것은 아니다. 리뷰를 반영하고 CI 실패를 고치는 과정은 필요하다. CI를 수정할 때는 이렇게 지시했다.</p>
<blockquote>
<p>CI 실패 전부 다 고쳐줘</p>
</blockquote>
<p><a href="https://github.com/delinoio/oss/pull/1726">PR #1726이 포함된 Stack</a>이 실제 사례다. 이 Stack에는 PR 11개가 들어 있었다. 리뷰 반영과 CI 수정을 몇 차례 거친 뒤, Stack 안의 PR을 전부 한 번에 머지했다.</p>
<p>수정 없이 한 번에 끝났다는 뜻은 아니다. 준비가 끝난 PR들을 하나씩 머지하면서 충돌을 계속 해결해야 했던 문제가 해결됐다는 뜻이다. 예전 방식으로 이 정도 PR을 모두 처리하려면 머지 충돌을 고치는 데 한참 걸렸다.</p>
<p>이번 Stack에서 처리한 작업은 다음과 같다.</p>
<table>
<thead>
<tr>
<th>PR</th>
<th>작업</th>
<th>이슈</th>
</tr>
</thead>
<tbody><tr>
<td><a href="https://github.com/delinoio/oss/pull/1716">#1716</a></td>
<td>Usage 필터 자동 적용</td>
<td><a href="https://github.com/delinoio/oss/issues/1698">#1698</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1717">#1717</a></td>
<td>전역 검색 단축키 제거</td>
<td><a href="https://github.com/delinoio/oss/issues/1697">#1697</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1718">#1718</a></td>
<td>키보드 도움말에서 단축키 실행</td>
<td><a href="https://github.com/delinoio/oss/issues/1696">#1696</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1719">#1719</a></td>
<td>워크플로우 간 Runner 선택 기억</td>
<td><a href="https://github.com/delinoio/oss/issues/1695">#1695</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1720">#1720</a></td>
<td>구독 아이콘과 저장된 사용 한도 표시</td>
<td><a href="https://github.com/delinoio/oss/issues/1694">#1694</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1721">#1721</a></td>
<td>Usage 상세 정보를 탭으로 구성</td>
<td><a href="https://github.com/delinoio/oss/issues/1693">#1693</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1722">#1722</a></td>
<td>세션 목록에 상태 표시와 작업 메뉴 추가</td>
<td><a href="https://github.com/delinoio/oss/issues/1692">#1692</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1723">#1723</a></td>
<td>Server 설정 안에 Network 설정 배치</td>
<td><a href="https://github.com/delinoio/oss/issues/1691">#1691</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1724">#1724</a></td>
<td>시작 시 프로세스 인덱스 생성 조건 수정</td>
<td><a href="https://github.com/delinoio/oss/issues/1690">#1690</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1725">#1725</a></td>
<td>Account storage 표시 제거</td>
<td><a href="https://github.com/delinoio/oss/issues/1689">#1689</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1726">#1726</a></td>
<td>실패 원인과 복구 방법을 해당 화면에 표시</td>
<td><a href="https://github.com/delinoio/oss/issues/1699">#1699</a></td>
</tr>
</tbody></table>
<h2>배치는 자기 전에</h2>
<p>배치를 언제 시작할지는 적당히 상황을 보고 정한다. 써 보니 자러 가기 전에 돌리는 게 가장 좋았다.</p>
<p><code>$slop-fix-batch</code>는 서브에이전트를 활용해서 여러 이슈를 병렬로 고친다. 그만큼 작업 기기의 CPU와 메모리를 많이 점유한다. 내가 기기를 쓰지 않는 시간에 돌리는 편이 좋다.</p>
<p>단점도 있다. 이슈를 모아서 배치로 처리하다 보니, 발견하자마자 고쳐지는 방식은 아니다.</p>
<p>그래도 PR을 잔뜩 만든 다음 머지 충돌을 해결하느라 시간을 쓰던 문제는 이 방식으로 해결했다. 내가 사용하는 스킬들은 모두 <a href="https://github.com/kdy1/kdy1-scripts">kdy1/kdy1-scripts</a>에 공개해 두었다.</p>
]]></content:encoded></item><item><title><![CDATA[AI Workflow Update]]></title><description><![CDATA[In my previous post, I described how I used Labor0 and Codex to run dozens of tasks in parallel. My workflow has changed since then. I no longer use…]]></description><link>https://kdy1.dev/2026-10-8-ai-workflow-update</link><guid isPermaLink="true">https://kdy1.dev/2026-10-8-ai-workflow-update</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Thu, 08 Oct 2026 01:58:21 GMT</pubDate><content:encoded><![CDATA[<p>In <a href="https://kdy1.dev/2026-9-6-humans-are-always-the-bottleneck">my previous post</a>, I described how I used Labor0 and Codex to run dozens of tasks in parallel. My workflow has changed since then. I no longer use Labor0, and I now work with skills that I have made public.</p>
<p>The latest problem I solved was what happens after generating all those pull requests. Creating PRs was easy. Getting all of them merged took far too long.</p>
<h2>The issue tracker is my prompt repository</h2>
<p>I always use <code>$add-issue</code> to create detailed issues. In practice, I use the issue tracker as a repository of prompts.</p>
<p>The idea is simple: once I have concrete issues written down, processing them in parallel is easy. Each issue describes the work, so I can select a batch later and ask the agent to handle it.</p>
<p>But as I processed more work, another bottleneck appeared. With around 30 PRs open, merge conflicts kept coming up. Resolving conflicts and rebasing took too much time.</p>
<p>Labor0 handled this through dependency analysis, but I no longer use it. I initially tried running parallel sessions in Codex. That made it easy to produce PRs, but merging all of them still took too long.</p>
<p>Eventually, I found that stacked PRs worked better for this workflow. I turned that approach into a skill.</p>
<h2>From dozens of issues to a stack of PRs</h2>
<p>Now I create dozens of issues with a skill, select them using labels or other conditions, and run <code>$slop-fix-batch</code>. The skill processes the issues and creates stacked PRs.</p>
<p>In my open-source repository, <a href="https://github.com/delinoio/oss">delinoio/oss</a>, I invoke it like this:</p>
<pre><code class="language-text">$slop-fix-batch sort:updated-desc is:issue state:open label:slop-batch author:kdy1
</code></pre>
<p>Creating the PRs does not finish the job. Review feedback still needs to be addressed, and CI failures still need to be fixed. For CI, my instruction was simply:</p>
<blockquote>
<p>Fix all CI failures.</p>
</blockquote>
<p><a href="https://github.com/delinoio/oss/pull/1726">The stack containing PR #1726</a> is a concrete example. It contained 11 PRs. After a few rounds of addressing review feedback and fixing CI, I merged the entire stack at once.</p>
<p>There were still several iterations before the stack was ready. What changed was the merge process: I no longer had to spend ages resolving conflicts as I worked through the individual PRs.</p>
<p>These were the 11 PRs and their corresponding issues:</p>
<table>
<thead>
<tr>
<th>PR</th>
<th>Change</th>
<th>Issue</th>
</tr>
</thead>
<tbody><tr>
<td><a href="https://github.com/delinoio/oss/pull/1716">#1716</a></td>
<td>Apply Usage filters automatically</td>
<td><a href="https://github.com/delinoio/oss/issues/1698">#1698</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1717">#1717</a></td>
<td>Remove the global Search shortcut</td>
<td><a href="https://github.com/delinoio/oss/issues/1697">#1697</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1718">#1718</a></td>
<td>Run shortcuts from keyboard help</td>
<td><a href="https://github.com/delinoio/oss/issues/1696">#1696</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1719">#1719</a></td>
<td>Remember Runner choices across workflows</td>
<td><a href="https://github.com/delinoio/oss/issues/1695">#1695</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1720">#1720</a></td>
<td>Show subscription icons and saved quota</td>
<td><a href="https://github.com/delinoio/oss/issues/1694">#1694</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1721">#1721</a></td>
<td>Organize Usage details into tabs</td>
<td><a href="https://github.com/delinoio/oss/issues/1693">#1693</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1722">#1722</a></td>
<td>Add session row states and action menus</td>
<td><a href="https://github.com/delinoio/oss/issues/1692">#1692</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1723">#1723</a></td>
<td>Embed Network settings in Server preferences</td>
<td><a href="https://github.com/delinoio/oss/issues/1691">#1691</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1724">#1724</a></td>
<td>Correct when startup process indexes are created</td>
<td><a href="https://github.com/delinoio/oss/issues/1690">#1690</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1725">#1725</a></td>
<td>Remove Account storage presentation</td>
<td><a href="https://github.com/delinoio/oss/issues/1689">#1689</a></td>
</tr>
<tr>
<td><a href="https://github.com/delinoio/oss/pull/1726">#1726</a></td>
<td>Show failure causes and recovery controls inline</td>
<td><a href="https://github.com/delinoio/oss/issues/1699">#1699</a></td>
</tr>
</tbody></table>
<h2>Run the batch before bed</h2>
<p>I start batches whenever it seems like a good time. So far, running one before going to bed has worked best.</p>
<p><code>$slop-fix-batch</code> uses subagents to fix issues in parallel, which consumes a lot of CPU and memory on the machine running it. I prefer to run it while I am not using that machine.</p>
<p>There is a downside: because this is a batch workflow, issues do not get fixed as soon as I discover them.</p>
<p>But it has solved the problem I was running into—creating a pile of PRs, then spending too much time resolving merge conflicts to get them all merged.</p>
<p>All of my skills are available in <a href="https://github.com/kdy1/kdy1-scripts">kdy1/kdy1-scripts</a>.</p>
]]></content:encoded></item><item><title><![CDATA[JSONLLM:  JSON 을 위한 바이브 모델]]></title><description><![CDATA[빠른 JSON 생성 API가 필요해서, 직접 모델을 학습시켜봤다]]></description><link>https://kdy1.dev/2026-10-5-jsonllm-experiment-ko</link><guid isPermaLink="true">https://kdy1.dev/2026-10-5-jsonllm-experiment-ko</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Mon, 05 Oct 2026 10:00:37 GMT</pubDate><content:encoded><![CDATA[<p>나는 빠르고 똑똑한 JSON 생성 API가 필요하다. AI 기반 앱을 만들다 보면 타입이 있는 데이터를 생성해야 하는 일이 정말 많다. 그때마다 출력 형식이 제대로 맞지 않거나, 결과를 기다리는 시간이 너무 길어서 고생한다.</p>
<p>그래서 <a href="https://github.com/delinoio/jsonllm">JSONLLM</a>이라는 작은 POC를 만들었다. 내가 이 모델을 서빙해서 사업을 하려는 것은 아니다. OpenAI나 Anthropic처럼 기술력과 자원이 있는 회사가 이 문제를 제대로 풀어줬으면 한다. 하지만 내가 필요하다고 말한다고 해서 만들어줄 곳들은 아니니, 개인적으로라도 직접 실험해보고 결과를 공개하려고 했다.</p>
<p>나는 AI를 전문적으로 연구하는 사람이 아니라 개발자다. LLM으로 어디까지 할 수 있는지 궁금해서 이런저런 시도를 많이 해봤다. 요즘은 LLM이 코드를 잘 작성하니, 모델 훈련도 바이브코딩으로 진행했다. 그 과정에서 시행착오도 꽤 겪었다.</p>
<p>이번 실험에서는 필드를 묶어서 처리하는 방식의 효과를 확인했다. 동시에 정확도와 긴 응답의 지연 시간, 동시 요청 처리에서는 큰 한계도 확인했다. 이 글은 그 가능성과 한계를 함께 소개하려는 글이다.</p>
<p>개발하면서 반복해서 부딪힌 문제는 구조화된 출력이었다. 여기서 말하는 문제는 JSON 스키마 자체를 작성하는 일이 아니다. 스키마를 입력으로 주고, 그 스키마에 맞는 결과를 생성하는 과정이다. Structured Outputs를 사용할 수 있어도, 내가 만들려는 사용자 경험에 적용하기에는 너무 느리다고 느꼈다. 출력이 조금만 커져도 기다리는 시간이 심각해졌다.</p>
<p>JSON은 표현이 장황한 포맷이다. 모델이 JSON 전체를 텍스트로 생성하면 값뿐 아니라 필드 이름과 구조를 표현하는 토큰까지 출력해야 한다. 애플리케이션이 이미 알고 있는 구조도 생성 과정에 들어간다. 나는 이 방식에 줄일 수 있는 일이 많다고 생각했다.</p>
<p>이번 POC의 주 실험 대상은 GenUI다. 쇼핑몰이나 개인 비서처럼 GenUI를 적용할 수 있는 영역이 분명히 보이고, 앞으로 중요한 사용자 경험이 될 수 있다고 생각한다. 그런데 UI를 JSON으로 표현하고 그것을 모델이 생성하는 구조에서는 JSON 생성 속도가 그대로 사용자 경험의 제약이 된다. 화면에 필요한 데이터가 늦게 나오면, 사용자는 그만큼 기다려야 한다.</p>
<p>이 문제를 고민하던 중 <a href="https://x.com/ctatedev/status/2101022101750571357">json-render에 Jev를 붙여본 실험</a>을 봤다. 원래부터 갖고 있던 고민이 그 게시물을 보면서 조금 더 구체적인 아이디어가 됐다. 내가 원한 것은 컴포넌트 선택을 넘어 프로퍼티의 값과 JSON 트리까지 빠르게 만들어내는 방식이었다.</p>
<p>이 과정에서 <a href="https://github.com/TypeLLM/TypeLLM">TypeLLM</a>을 많이 참고했고, 아이디어도 많이 얻었다. TypeLLM은 기존 모델의 구조나 가중치를 바꾸지 않고 타입이 있는 출력을 생성한다. 문자열과 숫자 생성, 독립적인 필드의 병렬 처리, 필드 사이의 의존 관계, 공통 문맥 재사용도 이미 지원한다. 이런 기능 자체를 JSONLLM의 새로운 아이디어라고 주장하려는 것은 아니다.</p>
<p>JSONLLM에서는 이 실행 방식에 맞춰 모델을 학습시키는 실험을 했다. Qwen3.5-4B를 개별 필드의 판단과 값 생성에 맞춰 LoRA로 미세조정하고, 전용 런타임과 연결했다.</p>
<p>애플리케이션은 구조와 규칙을 제공한다. 모델은 아직 결정되지 않은 값에 답한다. 계산, 기존 데이터의 정확한 복사, 상태 변경, 최종 JSON 조립은 코드가 처리한다. 독립적인 필드는 함께 처리하고, 다른 필드의 답이 필요한 경우에는 의존 관계에 따라 순서대로 처리한다. 공통 문맥을 한 번 처리한 뒤 그 캐시를 각 필드에서 재사용하는 방식도 구현했다. <a href="https://github.com/delinoio/jsonllm/blob/main/docs/design.md">설계 문서</a></p>
<p>예를 들어 저장소의 주문 예제에는 “배송지를 바꾸고 싶고, 급하지는 않다”는 요청이 있다. 모델이 판단하는 것은 어떤 컴포넌트를 사용할지, 긴급한 요청인지 같은 항목이다. 주문 번호와 주소를 가져오고, 단가와 수량을 곱하고, 최종 UI 데이터를 조립하는 일은 코드가 담당한다.</p>
<p>현재 구현에서는 애플리케이션이 컴포넌트와 구조를 미리 정의한다. 임의의 JSON 트리를 자유롭게 설계하거나 일반적인 워크플로우를 만들어내는 단계까지 구현한 것은 아니다. 내가 기대하는 최종 모습과 지금 만든 POC의 범위에는 아직 거리가 있다.</p>
<p>모델은 Qwen3.5-4B를 사용했다. 개인적으로 진행하는 실험이고, 이걸로 돈을 벌려는 것도 아니어서 처음부터 큰 모델에 많은 비용을 쓰기는 어려웠다. 학습 데이터는 8,000개, 검증과 테스트 데이터는 각각 1,000개였고, 한국어와 영어를 절반씩 포함했다. 합성 데이터 생성에는 DeepSeek 모델을 사용했다. 필드 단위로 변환한 학습 예제 15,619개로 한 번의 epoch를 학습하는 데 약 102분이 걸렸다. <a href="https://huggingface.co/kdy1/JSONLLM-Qwen3.5-4B-v0.1">모델 카드</a></p>
<p>비용은 생각보다 많이 들었다. 훨씬 저렴하게 만들 수도 있었을 텐데, AI를 잘 모르다 보니 비효율적으로 진행한 부분이 있었다. 작업용 레포지토리도 여러 개 만들었고, 훈련도 여러 번 했다. 초기에 약관 확인을 제대로 하지 못해 다시 훈련한 일도 있었다. 지금 정리한 모델은 약관을 확인하고 다시 훈련한 결과물이다.</p>
<p>첫 번째 작업용 레포에서는 약 24달러를 썼다. 두 번째 레포의 비용은 다음과 같다.</p>
<table>
<thead>
<tr>
<th>작업</th>
<th>비용</th>
</tr>
</thead>
<tbody><tr>
<td>초기 학습 및 속도 재현 실험</td>
<td>$140</td>
</tr>
<tr>
<td>문맥 공유 모델 학습 및 평가</td>
<td>$232</td>
</tr>
<tr>
<td>지연 최적화 A/B 테스트</td>
<td>$22.50</td>
</tr>
<tr>
<td>데이터 합성, 재훈련 및 평가</td>
<td>$29.07</td>
</tr>
<tr>
<td>합계</td>
<td>$423.57</td>
</tr>
</tbody></table>
<p>이후 비교 벤치마크에 약 64.44달러가 추가됐다. 앞선 시행착오까지 합하면 전체 지출은 약 512달러다. 추가 벤치마크 비용은 설치, 실패한 시도, 스토리지와 결과 회수까지 포함한 추정치다. 저장소에 기록된 마지막 학습·평가 비용 29.07달러를 전체 프로젝트 비용으로 보면 안 된다.</p>
<p>돈이 조금 아깝기는 했다. 그래도 실험을 시작했으면 끝까지 확인해봐야 한다고 생각해서 밀어붙였다. 지금 공개를 준비하는 저장소는 그 과정을 정리한 버전이다.</p>
<p>비교 벤치마크에서는 모델 가중치를 고정하고, 새로운 합성 과제로 실행 방식의 차이를 확인했다. JSON 전체 생성, 필드별 순차 생성, 독립 필드 배치 처리, 공통 문맥을 공유하는 필드 처리, vLLM의 JSON 생성 방식을 비교했다. 원본 Qwen과 미세조정한 JSONLLM 모두 같은 H100 80GB에서 평가했고, 계획한 540개 실험을 완료했다. 이 단계에서는 재훈련하지 않았다. <a href="https://github.com/delinoio/jsonllm/blob/main/docs/design-benchmark.md">비교 방법과 전체 결과</a></p>
<p>가장 명확한 긍정적인 결과는 독립 필드의 배치 처리였다. 같은 과제끼리 지연 시간을 비교했을 때, 필드를 하나씩 처리하는 방식보다 두 모델 모두 중앙값 기준 약 3.14배의 속도 개선이 있었다. 원본 모델의 정확도는 같았고, JSONLLM은 256개 중 한 개를 더 맞혔다. 이 표본에서는 정확도를 떨어뜨리지 않고 독립적인 작업을 함께 처리하는 효과가 나타났다.</p>
<p>공통 문맥 공유의 결과는 조건에 따라 달랐다. 짧은 문맥을 사용하는 기본 과제에서는 일반 배치 처리보다 느렸다. 공통 문맥을 반복해서 처리하는 양은 줄었지만, 캐시를 복사하는 작업도 발생했다. 문맥을 길게 만든 탐색 실험에서는 공유 방식이 더 빨랐다. JSONLLM에서는 공통 문맥이 약 513토큰일 때 약 1.46배, 1,026토큰일 때 약 1.64배 빨랐다. 다만 각 조건의 고유 과제가 32개였으므로, 더 큰 표본으로 확인할 필요가 있다.</p>
<p>그리고 JSON 전체 생성과 비교하면 정확도 문제가 드러났다. JSONLLM의 기본 과제 결과는 다음과 같다. 지연 시간은 다섯 번의 실험에서 얻은 통계의 중앙값이며, 정확도는 한 레코드의 모든 필드가 맞아야 정답으로 계산했다.</p>
<table>
<thead>
<tr>
<th>실행 방식</th>
<th>정확도</th>
<th>p50 지연</th>
<th>p95 지연</th>
<th>초당 완전 정답 수</th>
</tr>
</thead>
<tbody><tr>
<td>JSON 전체 생성</td>
<td>78.52%</td>
<td>2,262ms</td>
<td>3,816ms</td>
<td>0.308</td>
</tr>
<tr>
<td>필드별 순차 생성</td>
<td>64.84%</td>
<td>595ms</td>
<td>7,376ms</td>
<td>0.297</td>
</tr>
<tr>
<td>독립 필드 배치 처리</td>
<td>65.23%</td>
<td>191ms</td>
<td>4,913ms</td>
<td>0.499</td>
</tr>
<tr>
<td>문맥 공유 필드 처리</td>
<td>65.23%</td>
<td>250ms</td>
<td>4,900ms</td>
<td>0.490</td>
</tr>
<tr>
<td>vLLM JSON 생성</td>
<td>75.39%</td>
<td>323ms</td>
<td>851ms</td>
<td>1.781</td>
</tr>
</tbody></table>
<p>문맥 공유 방식은 JSON 전체 생성보다 중앙값 지연 시간이 짧았다. 하지만 정확도가 약 13.3%p 낮았고, p95 지연 시간도 더 길었다. 따라서 이 결과로 “같은 품질의 JSON을 더 빠르게 생성했다”고 말할 수는 없다.</p>
<p>vLLM은 이 비교에서 초당 완전 정답 수가 가장 많았고 p95도 가장 짧았다. 동시 요청을 늘리는 실험에서도 현재 JSONLLM 런타임보다 유리했다. JSONLLM에는 요청 단위의 잠금이 남아 있어서, 한 요청 안의 필드를 함께 처리하더라도 여러 요청을 효율적으로 처리하는 데는 한계가 있었다.</p>
<p>트리와 워크플로우 실험의 결과는 더 좋지 않았다. 여덟 개 후보 노드의 존재 여부, 종류, 연결 관계를 선택하는 제한된 과제에서도 필드별 생성 방식은 완전 정답 기준 0%였다. 형식에 맞는 값을 출력한다고 해서 올바른 구조가 만들어지는 것은 아니었다.</p>
<p>처음의 제한된 평가에서 얻었던 높은 정확도를 새로운 과제에 그대로 적용할 수 없다는 점도 확인했다. 이번 결과는 독립 필드 배치 처리의 효과를 보여주지만, 현재 모델과 런타임이 일반적인 JSON 생성이나 GenUI를 해결했다는 근거는 되지 않는다. TypeLLM과의 직접 성능 비교도 아직 하지 않았다.</p>
<p>그럼에도 내가 이 문제를 계속 중요하게 보는 이유는 단순하다. 나는 지금도 앱을 만들면서 이런 API가 필요하다. GenUI뿐 아니라 워크플로우나 일반적인 트리 형태의 데이터를 생성할 때도, 타입이 있는 값을 빠르고 정확하게 얻는 기능이 필요하다.</p>
<p>내 설계가 정답인지는 모르겠다. 이번 실험에서도 잘된 부분과 실패한 부분이 함께 나왔다. 다만 모델이 무엇을 판단하고, 코드가 무엇을 처리하며, 독립적인 판단을 어떻게 함께 실행할지를 모델과 런타임 양쪽에서 다뤄볼 가치가 있다고 생각한다.</p>
<p>이걸 내가 직접 서비스로 운영할 계획은 없다. 모델을 서빙할 자본도 넉넉하지 않고, 루나급의 지능을 가진 모델을 직접 만들고 운영하는 일도 쉽지 않다. OpenAI나 Anthropic 같은 회사가 더 좋은 모델을 기반으로 증류를 하든, 실행 방식을 개선하든, 빠른 구조화 데이터 생성에 맞는 모델과 API를 만들어줬으면 한다. 그리고 OpenRouter, Vercel AI Gateway, Cloudflare AI Gateway 같은 곳에서 편하게 사용할 수 있으면 좋겠다.</p>
<p>코드는 <a href="https://github.com/delinoio/jsonllm">GitHub</a>에, 모델 가중치와 학습·평가 자료는 <a href="https://huggingface.co/kdy1/JSONLLM-Qwen3.5-4B-v0.1">Hugging Face</a>에 정리했다. 코드와 파생 모델, 포함된 합성 데이터는 Apache-2.0 라이선스로 공개되어있다.</p>
<p>이 실험이 널리 알려져서, 더 잘 만들 수 있는 사람들이 이 문제에 관심을 가져줬으면 한다. 조금 특이한 목적일 수도 있지만, 나는 그런 API가 정말 필요하다.</p>
]]></content:encoded></item><item><title><![CDATA[JSONLLM: Vibed AI Model for JSON]]></title><description><![CDATA[I experimented with something called JSONLLM]]></description><link>https://kdy1.dev/2026-10-5-jsonllm-experiment</link><guid isPermaLink="true">https://kdy1.dev/2026-10-5-jsonllm-experiment</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Mon, 05 Oct 2026 10:00:33 GMT</pubDate><content:encoded><![CDATA[<p>I want a fast, capable API for generating JSON. When I build AI-powered apps, I constantly need to generate typed data. And I keep running into the same problems: the output does not quite match the format I need, or it takes too long to arrive.</p>
<p>That led me to build a small proof of concept called <a href="https://github.com/delinoio/jsonllm">JSONLLM</a>. I am not planning to build a business around serving this model. What I really want is for a company like OpenAI or Anthropic to solve this problem properly. But I cannot expect them to build something just because I ask. So I decided to run an experiment myself and prepare the results for release.</p>
<p>I am a developer, and I do not specialize in AI research. I have tried all sorts of things because I am curious about how far LLMs can go. With current coding models, I could even get a training experiment running through vibe coding. I also made plenty of mistakes along the way.</p>
<p>The experiment showed a benefit from batching independent fields. It also exposed substantial problems with accuracy, long responses, and concurrent requests. I want to share both the useful results and the limits.</p>
<p>The problem I kept encountering was structured output. More specifically, I mean giving a model a JSON schema and asking it to produce data that conforms to that schema. Even with Structured Outputs available, the generation felt too slow for the user experiences I wanted to build. As the output grew, the delay became a serious problem.</p>
<p>JSON is verbose. When a model generates an entire JSON object as text, it emits field names and structural tokens alongside the actual values. Structure that the application already knows becomes part of the generation process. I kept wondering how much of that work we could avoid.</p>
<p>The main application I explored in this POC was generative UI, or GenUI. I can see clear uses for it in shopping apps and personal assistants, and I think it could become an important way of building user experiences. But when an interface is represented as JSON generated by a model, JSON generation speed becomes a direct constraint on the experience. If the data needed to build the interface arrives late, the user waits.</p>
<p>While thinking about this, I came across <a href="https://x.com/ctatedev/status/2101022101750571357">an experiment combining json-render with Jev</a>. I had already been considering the JSON generation problem, but that post gave me a more concrete idea of how to approach it. I wanted something that could go beyond component selection and quickly generate property values and JSON trees.</p>
<p>I also drew heavily on <a href="https://github.com/TypeLLM/TypeLLM">TypeLLM</a>. It was an important reference and a source of ideas. TypeLLM produces typed outputs without changing the underlying model’s architecture or weights. It already supports strings and numbers, parallel execution of independent fields, dependencies between fields, and shared-context reuse. I am not claiming those features as new ideas from JSONLLM.</p>
<p>With JSONLLM, I experimented with training a model for this execution interface. I fine-tuned Qwen3.5-4B with LoRA on field-level decisions and value generation, then connected it to a custom runtime.</p>
<p>The application supplies the structure and rules. The model answers questions about values that have not yet been determined. Code handles calculations, exact copies of existing data, state transitions, and final JSON assembly. Independent fields run together; fields that need earlier answers run in dependency order. I also implemented shared-context processing, where the runtime processes common context once and copies its cache for the field branches. <a href="https://github.com/delinoio/jsonllm/blob/main/docs/design.md">Design documentation</a></p>
<p>The repository’s order example makes this more concrete. A user says they want to change their shipping address and that it is not urgent. The model decides which component to use and whether the request is urgent. Code retrieves the order details, multiplies the unit price by the quantity, and assembles the final UI data.</p>
<p>The current implementation requires the application to define the available components and structure. It does not freely design arbitrary JSON trees or generate general workflows. There is still a significant gap between this POC and what I ultimately want.</p>
<p>I used Qwen3.5-4B because this was a personal experiment with a limited budget. I was not planning to make money from it, so spending heavily on a larger model from the start was difficult to justify.</p>
<p>The dataset contained 8,000 training records, 1,000 validation records, and 1,000 test records, split evenly between English and Korean. A DeepSeek model generated the synthetic data. After converting the training records into 15,619 field-level examples, one epoch of training took about 102 minutes. <a href="https://huggingface.co/kdy1/JSONLLM-Qwen3.5-4B-v0.1">Model card</a></p>
<p>The overall process cost more than it needed to. Looking back, I could have done it much more cheaply. My lack of experience with AI training led to some inefficient decisions. I created multiple working repositories and trained multiple times. Early on, I also failed to check the applicable terms properly and had to repeat training. The model prepared for release was retrained after checking those terms.</p>
<p>I spent about $24 in the first working repository. The second repository’s costs broke down as follows:</p>
<table>
<thead>
<tr>
<th>Work</th>
<th>Cost</th>
</tr>
</thead>
<tbody><tr>
<td>Initial training and speed reproduction experiments</td>
<td>$140</td>
</tr>
<tr>
<td>Shared-context model training and evaluation</td>
<td>$232</td>
</tr>
<tr>
<td>Latency optimization A/B tests</td>
<td>$22.50</td>
</tr>
<tr>
<td>Data synthesis, retraining, and evaluation</td>
<td>$29.07</td>
</tr>
<tr>
<td>Total</td>
<td>$423.57</td>
</tr>
</tbody></table>
<p>The later comparative benchmark added approximately $64.44. Including the earlier experiments, that brings the overall spending to roughly $512. The additional benchmark estimate includes setup, failed attempts, storage, and recovery of the results.</p>
<p>The $29.07 recorded for the final data synthesis, retraining, and evaluation stage should therefore not be mistaken for the cost of the entire project.</p>
<p>Some of that spending felt avoidable. But I wanted to follow the experiment through and find out what actually worked. The repository I am preparing for release is the cleaned-up version of that process.</p>
<p>For the comparative benchmark, I froze the model weights and tested different execution methods on fresh synthetic tasks. I compared whole-JSON generation, serial field generation, batched independent fields, shared-context fields, and JSON generation through vLLM. Both the original Qwen model and the fine-tuned JSONLLM model ran on the same H100 80 GB. All 540 planned trials completed, with no retraining during this study. <a href="https://github.com/delinoio/jsonllm/blob/main/docs/design-benchmark.md">Methods and full results</a></p>
<p>The clearest positive result was batching independent fields. Comparing the same records, batching produced a median latency speedup of about 3.14× over processing fields one at a time, under both models. Accuracy stayed the same for the original model, while JSONLLM answered one additional record correctly out of 256. On this sample, batching improved speed without an observed loss of accuracy.</p>
<p>Shared context produced more mixed results. On the short-context core tasks, it was slower than ordinary batching. It reduced repeated context processing, but also required copying cache state.</p>
<p>In the exploratory longer-context tests, sharing became faster. For JSONLLM, it was about 1.46× faster than ordinary batching at roughly 513 common-context tokens, and about 1.64× faster at 1,026 tokens. However, each condition contained only 32 distinct records. Those results need confirmation on a larger sample.</p>
<p>Comparing field execution with whole-JSON generation exposed an accuracy problem. These are the core results for JSONLLM. Latency and throughput values are medians of the statistics from five trials. A record counts as correct only when every field is correct.</p>
<table>
<thead>
<tr>
<th>Method</th>
<th>Exact accuracy</th>
<th>p50 latency</th>
<th>p95 latency</th>
<th>Correct complete records/sec</th>
</tr>
</thead>
<tbody><tr>
<td>Whole JSON</td>
<td>78.52%</td>
<td>2,262 ms</td>
<td>3,816 ms</td>
<td>0.308</td>
</tr>
<tr>
<td>Serial fields</td>
<td>64.84%</td>
<td>595 ms</td>
<td>7,376 ms</td>
<td>0.297</td>
</tr>
<tr>
<td>Batched fields</td>
<td>65.23%</td>
<td>191 ms</td>
<td>4,913 ms</td>
<td>0.499</td>
</tr>
<tr>
<td>Shared-context fields</td>
<td>65.23%</td>
<td>250 ms</td>
<td>4,900 ms</td>
<td>0.490</td>
</tr>
<tr>
<td>vLLM JSON</td>
<td>75.39%</td>
<td>323 ms</td>
<td>851 ms</td>
<td>1.781</td>
</tr>
</tbody></table>
<p>Shared-context execution had much lower median latency than whole-JSON generation. But its accuracy was approximately 13.3 percentage points lower, and its p95 latency was worse. These results do not support a claim that it generated equally good JSON faster.</p>
<p>vLLM achieved the highest correct throughput and the lowest p95 latency in this comparison. It also handled increased concurrency better than the current JSONLLM runtime. JSONLLM still has a record-level lock: batching fields within a request does not translate into efficient execution of multiple requests.</p>
<p>The tree and workflow results were worse. Even in bounded tasks that asked the model to select the existence, type, and connections of eight candidate nodes, the typed-field methods scored 0% exact-record accuracy. Producing values with valid types did not ensure a correct structure.</p>
<p>The high accuracy from the earlier, restricted evaluation did not carry over to these new tasks. This study provides evidence for batching independent fields, but it does not establish that the current model and runtime solve general JSON generation or GenUI. I have not run a direct performance comparison against TypeLLM either.</p>
<p>I still think the problem matters because I need this capability in the apps I am building now. It applies to GenUI, workflows, and ordinary tree-shaped data. Being able to obtain typed values quickly and accurately is useful across all of them.</p>
<p>I do not know whether my design is the right one. The experiment produced both useful results and failures. I do think it is worth exploring how the model and runtime can work together: which decisions require the model, which operations belong in code, and which independent decisions can run together.</p>
<p>I do not plan to operate this as a service myself. I have limited capital for model serving, and building and serving a model with Luna-level intelligence is not something I can easily do.</p>
<p>I would like OpenAI or Anthropic to build a capable model and API for fast structured-data generation—whether through distillation from a stronger model, improvements to the execution interface, or another approach. Ideally, I could use it through OpenRouter, Vercel AI Gateway, or Cloudflare AI Gateway.</p>
<p>I have organized the code on <a href="https://github.com/delinoio/jsonllm">GitHub</a>, and the model weights, training data, and evaluation materials on <a href="https://huggingface.co/kdy1/JSONLLM-Qwen3.5-4B-v0.1">Hugging Face</a>. The code, derivative model, and included synthetic data are released under Apache-2.0.</p>
<p>I hope this experiment gets enough attention that people with the resources to build something better take an interest. That may be an unusual reason to train a model, but I really do need this API.</p>
]]></content:encoded></item><item><title><![CDATA[Programming Language in the AI era]]></title><description><![CDATA[These days, my preference is React and TypeScript for frontend development, and Go, TypeScript, then Rust for everything else. I really like Rust, and I…]]></description><link>https://kdy1.dev/2026-9-11-ai-and-programming-language</link><guid isPermaLink="true">https://kdy1.dev/2026-9-11-ai-and-programming-language</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Fri, 11 Sep 2026 02:02:47 GMT</pubDate><content:encoded><![CDATA[<p>These days, my preference is React and TypeScript for frontend development, and Go, TypeScript, then Rust for everything else.</p>
<p>I really like Rust, and I have used it a lot. But when I think about which language to choose for developing with AI, I rank Go highest. It seems to strike the best balance for building a fast verification loop.</p>
<h2>Bottlenecks in the iteration loop</h2>
<p>AI works incredibly fast. That means even a slightly slow part of the iteration loop can quickly become a bottleneck.</p>
<p>Developing with AI does not mean that AI’s working time—the time when the GPU is running—accounts for an overwhelmingly large share of the total. There are builds to wait for and tests to run.</p>
<p>This is the main reason I rank Go highest. It builds faster than Rust, and it runs things like tests faster than TypeScript. Its runtime performance is also pretty good considering how little time it takes to build.</p>
<p>Fast execution also means less time spent running tests. I also find that Go’s support for parallelism means test times grow much less sharply than they do with TypeScript as a project gets larger.</p>
<p>These days, human QA is the biggest bottleneck for me, and fast builds matter there too. When a build is slow during PR verification, QA slows down with it. Even as someone who likes Rust, I find its build times costly here.</p>
<h2>Rust’s checks are valuable, but expensive to pay for every time</h2>
<p>Rust catches a lot of problems. Its checks cover far more than Go’s <code>go test -race</code>. As I organize my thoughts for this post, I keep coming back to the feeling that Rust is both good and a bit excessive.</p>
<p>For most projects, I think running concurrency-related tests separately at regular intervals is enough. For something like a database, I would run them routinely, but that would mean shortening the interval. Running them every single time still seems wasteful to me.</p>
<p>The separate checks I have in mind are things like <code>go test -race</code>. I do not mean that these are equivalent to Rust’s compile-time checks. Rust catches much more.</p>
<p>But even recognizing the value of those checks, Rust builds are too slow for me to want to pay that cost every time. I do not think the frequency at which verification is needed always matches the frequency at which a build is needed.</p>
<h2>Even good type inference has a cost</h2>
<p>Rust’s type inference is a great feature. But when I wrote the code myself, I sometimes struggled to work out the types. I had to look through many files to figure out the right type.</p>
<p>Things were somewhat better when rust-analyzer worked well. But I developed in Rust before it existed, and even after it became available, it did not always work reliably. I still had to work without its help at times.</p>
<p>AI agents are so fast that I expect them to figure out types faster and better than I could. Even so, I do not feel that this gives me a reason to choose Rust when Go is available.</p>
<h2>How hard is it to get the performance?</h2>
<p>Rust is certainly a language with excellent performance. But using it well is much harder than people tend to think.</p>
<p>Imagine a senior developer unfamiliar with each language being asked by their company to build a highly parallel program in Go, TypeScript, and Rust. I would expect the Go version to be the fastest.</p>
<p>Handling system calls such as file reads efficiently is not particularly difficult in Go, but it is very difficult in Rust.</p>
<p>The difference, as I see it, is in how system calls are handled. Rust is designed to be usable in kernels, and that applies to async Rust as well. I see this design as part of what makes automatically inserting hooks around system calls difficult. Go, meanwhile, provides handling for system calls out of the box.</p>
<p>Unless a highly skilled developer designs the system properly, I think it is difficult to beat the handling Go already provides.</p>
<h2>Unfriendly error messages become an advantage</h2>
<p>Some of Go’s choices used to make me wonder why the language worked that way. In the AI era, I find those same choices helpful. Build error messages are one example.</p>
<p>Rust and TypeScript helpfully show code snippets in the terminal to explain what went wrong. Go tells you which line has which problem, and that is it. It does not even print every error. When I was coding by hand, I found this really frustrating.</p>
<p>But from an AI agent’s perspective, builds are fast, and the error messages do not consume much context either. The output I once found unfriendly has started to look like an advantage.</p>
<p>When developing with AI, I care about how quickly I can run the whole iteration loop, including builds, tests, and human QA. Right now, Go strikes the best balance for me.</p>
<hr />
<h2>Update: The options are limited</h2>
<p>This seemed so obvious that I forgot to mention it when writing this post, but you have to choose a language that AI writes well. That’s why this post focuses on Rust, Go, and TypeScript.</p>
]]></content:encoded></item><item><title><![CDATA[AI 시대의 프로그래밍 언어]]></title><description><![CDATA[요즘 내가 선호하는 언어는 프론트엔드에서는 React와 TypeScript, 그 외에는 Go, TypeScript, Rust 순이다. 나는 Rust를 정말 좋아하고 많이 써봤다. 그런데 AI와 개발할 때 어떤 언어를 고를지 생각하면, Go를 가장 높게 평가하게 된다. 검증…]]></description><link>https://kdy1.dev/2026-9-11-ai-and-programming-language-kr</link><guid isPermaLink="true">https://kdy1.dev/2026-9-11-ai-and-programming-language-kr</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Fri, 11 Sep 2026 02:02:45 GMT</pubDate><content:encoded><![CDATA[<p>요즘 내가 선호하는 언어는 프론트엔드에서는 React와 TypeScript, 그 외에는 Go, TypeScript, Rust 순이다.</p>
<p>나는 Rust를 정말 좋아하고 많이 써봤다. 그런데 AI와 개발할 때 어떤 언어를 고를지 생각하면, Go를 가장 높게 평가하게 된다. 검증 루프를 빠르게 구성하기에 균형이 가장 잘 맞는 것 같다.</p>
<h2>이터레이션 루프의 병목</h2>
<p>AI는 작업 속도가 엄청나게 빠르다. 그래서 이터레이션 루프의 구성 요소가 조금만 느려도 금방 병목이 된다.</p>
<p>AI로 개발한다고 해서 전체 작업 시간 중 AI가 일하는 시간, 그러니까 GPU가 돌아가는 시간의 비중이 엄청나게 높은 것은 아니다. 빌드를 기다리고, 테스트 실행을 기다려야 한다.</p>
<p>내가 Go를 가장 높게 평가하는 이유가 여기에 있다. Rust보다 빌드가 빠르고, TypeScript보다 테스트 같은 것들의 실행이 빠르다. 빌드 시간이 엄청나게 짧은 것에 비하면 런타임 성능도 괜찮다.</p>
<p>실행 속도가 빠르다는 것은 테스트를 돌리는 시간도 짧다는 뜻이다. Go는 병렬 처리가 잘 되는 언어라 프로젝트가 커질 때 테스트가 느려지는 정도도 TypeScript보다 훨씬 덜하다고 본다.</p>
<p>요즘은 사람이 수행하는 QA가 가장 큰 병목인데, 이것 역시 빌드가 빨라야 한다. PR을 검증할 때 빌드가 느리면 QA까지 느려진다. Rust를 좋아하는 나도 이 부분에서는 빌드 시간이 부담스럽다.</p>
<h2>Rust의 검증은 좋지만, 매번 부담하기에는 무겁다</h2>
<p>Rust는 많은 문제를 잡아준다. Go의 <code>go test -race</code>와 비교할 수 없을 정도로 검증 범위가 넓다. 글을 쓰려고 생각을 정리하다 보니, Rust가 좋으면서도 지나치다는 느낌이 든다.</p>
<p>내 생각에는 대부분의 프로젝트에서 동시성 관련 테스트는 주기적으로 따로 돌리면 충분하다. 데이터베이스 같은 프로젝트라면 일상적으로 돌리겠지만, 그것도 주기를 짧게 잡는 것이지 매번 돌리는 것은 낭비일 것 같다.</p>
<p>여기서 별도로 돌릴 검사로 생각한 것은 <code>go test -race</code> 같은 것들이다. 이것이 Rust의 컴파일 시 검증과 동등하다는 뜻은 아니다. Rust는 훨씬 많은 것을 잡아준다.</p>
<p>다만 그 검증의 가치를 인정하더라도, 매번 빌드할 때마다 비용을 부담하기에는 Rust의 빌드가 너무 느리다. 검증이 필요한 주기와 빌드가 필요한 주기가 꼭 같지는 않다고 본다.</p>
<h2>좋은 타입 추론에도 비용은 있다</h2>
<p>Rust의 타입 추론은 정말 좋은 기능이다. 하지만 사람인 내가 직접 코딩할 때도 타입을 파악하는 데 애먹었다. 올바른 타입을 알기 위해 살펴봐야 하는 파일이 많았다.</p>
<p>rust-analyzer가 잘 작동할 때는 그나마 나았다. 하지만 나는 그것이 없던 시절에도 개발했고, 생긴 뒤에도 항상 제대로 작동하는 것은 아니라 도움 없이 개발하기도 했다.</p>
<p>AI 에이전트는 워낙 빠르니 나보다 타입을 빨리 파악하고, 더 잘할 것이다. 그래도 Go를 두고 굳이 Rust를 고를 이유는 없는 것 같다.</p>
<h2>언어의 성능을 끌어내는 난이도</h2>
<p>Rust가 성능이 엄청나게 좋은 언어인 것은 맞다. 하지만 사람들이 생각하는 것보다 Rust를 제대로 쓰는 것은 훨씬 어렵다.</p>
<p>예를 들어 각 언어에 익숙하지 않은 시니어 개발자가 회사의 요구로 Go, TypeScript, Rust를 사용해 병렬 처리가 아주 많은 프로그램을 만든다고 해보자. 나는 Go로 만든 프로그램이 가장 빠를 것이라고 예상한다.</p>
<p>파일 읽기 같은 시스템 콜을 고성능으로 처리하는 것이 Go에서는 그리 어렵지 않지만, Rust에서는 정말 어렵기 때문이다.</p>
<p>내가 보는 차이는 시스템 콜을 다루는 방식에 있다. Rust는 커널에서도 쓸 수 있게 설계됐고, async Rust도 마찬가지다. 나는 이런 설계가 시스템 콜에 자동으로 훅을 넣는 처리를 어렵게 하는 배경이라고 본다. 반면 Go는 시스템 콜에 대한 처리를 기본으로 제공한다.</p>
<p>엄청난 실력자가 제대로 설계한 것이 아니라면, Go가 제공하는 처리를 직접 설계해서 이기기는 어렵다고 생각한다.</p>
<h2>불친절한 오류 메시지가 장점이 되다</h2>
<p>직접 코딩할 때는 Go가 왜 이런 선택을 했나 싶었던 부분도 AI 시대에는 도움이 된다. 빌드 오류 메시지가 그중 하나다.</p>
<p>Rust나 TypeScript는 터미널에 코드 스니펫까지 보여주면서 어떤 오류가 있는지 친절하게 알려준다. Go는 어느 줄에 어떤 문제가 있는지 알려주고 끝이다. 심지어 오류를 전부 출력하지도 않는다. 직접 코딩할 때는 정말 짜증났다.</p>
<p>그런데 AI 입장에서는 빌드도 빠른데 오류 메시지로 컨텍스트를 많이 쓰지도 않는다. 내가 불친절하다고 느꼈던 출력 방식이 오히려 장점으로 보이기 시작했다.</p>
<p>AI와 개발할 때는 빌드, 테스트, 사람이 수행하는 QA까지 포함한 이터레이션 루프를 얼마나 빠르게 돌릴 수 있는지가 중요하다. 지금 내게는 Go가 그 균형이 가장 잘 맞는 언어다.</p>
<hr />
<h2>Update: 선택지는 제한되어 있다</h2>
<p>너무 당연한 내용이라서 글 쓸 때 까먹었는데, AI가 잘 작성하는 언어 중에서 골라야 한다. 이 글이 Rust, Golang, TypeScript에 집중되어 있는 이유이다.</p>
]]></content:encoded></item><item><title><![CDATA[사람은 언제나 병목이다]]></title><description><![CDATA[50개가 넘는 AI 세션과 함께 개발하기]]></description><link>https://kdy1.dev/2026-9-6-humans-are-always-the-bottleneck-kr</link><guid isPermaLink="true">https://kdy1.dev/2026-9-6-humans-are-always-the-bottleneck-kr</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Sun, 06 Sep 2026 05:20:54 GMT</pubDate><content:encoded><![CDATA[<p>나는 <code>kdy1</code>이라는 닉네임으로 활동하는 개발자다. 오픈소스 컴파일러 프로젝트인 SWC를 만들었고, 이전에는 Deno와 Vercel에서 일했다. 요즘은 Zephyr Cloud IO의 <a href="https://labor0.com">Labor0</a>, <a href="https://github.com/ZephyrCloudIO/watchtower">Watchtower</a>, <a href="http://theaiplatform.app/">theaiplatform.app</a>을 함께 만들고 있다.</p>
<p>그중에서도 최근 가장 열심히 만드는 제품은 Labor0다. Labor0의 핵심 아이디어는 간단하다.</p>
<p><strong>AI가 작업을 주도한다.</strong></p>
<p>인간은 언제나 병목이다. 이것이 내 철칙이다.</p>
<p>물론 HITL(Human in the Loop)은 필수다. 제품과 기술에 관한 결정은 사람이 내려야 하고, PR도 사람이 최종 검토하고 머지해야 한다. 다만 AI가 작업하는 동안 사람을 호출하는 횟수는 가능한 한 줄여야 한다.</p>
<p>Labor0는 사람의 결정이 필요할 때 웹 푸시 등으로 질문을 보낸다. 사람이 한 PR을 검토하고 있는 동안에는 다음 작업을 자동으로 시작한다. 사람이 모든 과정에 계속 붙어 있는 대신, 꼭 필요한 결정 지점에만 참여하는 구조다.</p>
<h2>AI에게 일을 시킬 때의 제1원칙</h2>
<p>내가 AI에게 일을 시킬 때 가장 중요하게 생각하는 원칙은 언제나 같다.</p>
<p><strong>작업을 충분히 작은 단위로 쪼개야 한다.</strong></p>
<p>한 PR이 너무 크면 사람도 리뷰하기 어렵고 AI도 리뷰하기 어렵다. 결국 리뷰 품질이 떨어진다.</p>
<p>나는 AI가 등장하기 전부터 코드 리뷰를 아주 많이 했다. GitHub에 기록된 PR 리뷰 횟수가 1년에 5천 번을 넘을 정도였다. 그 경험을 통해 큰 PR에서는 제대로 된 리뷰가 어렵다는 것을 배웠다.</p>
<p>AI도 비슷하다. 컨텍스트 크기 같은 이유가 영향을 주는 것 같지만, 정확한 원인과 별개로 작업이 커질수록 결과를 검증하기 어려워지는 것은 분명하다.</p>
<p>유지 가능한 바이브 코딩을 하려면 작업을 나누는 과정이 필수다. Labor0는 이 과정을 플랫폼으로 만든다. 작업이 크면 여러 작업과 PR로 나누고, 작업 사이에 의존성이 있다면 그 순서에 맞춰 실행한다. 서로 독립적인 작업은 병렬로 진행한다.</p>
<p>다만 이렇게 많은 작업을 병렬로 돌리려면 입력부터 상세해야 한다. 내가 수십 개의 세션을 동시에 운영할 수 있는 중요한 이유도 이슈와 PRD가 매우 구체적이기 때문이다.</p>
<p>여기서 내가 항상 사용하는 것이 <a href="https://github.com/kdy1/kdy1-scripts/tree/f9079364d84a9d3e1eaa1c8b8c9dbc60ee4e46de/skills/add-issue">$add-issue</a>와 <a href="https://github.com/kdy1/kdy1-scripts/tree/f9079364d84a9d3e1eaa1c8b8c9dbc60ee4e46de/skills/write-prd">Write PRD</a> 스킬이다.</p>
<p><code>$add-issue</code>는 확인된 버그를 재현 사례와 구현 범위가 포함된 상세한 GitHub 이슈로 만든다. Write PRD를 사용하면 필요한 결정을 둘러싼 대화가 이어진다. 결정은 모두 내가 직접 내리지만, 큰 프로젝트의 규모와 비교하면 사람이 내려야 하는 결정은 생각보다 많지 않다. 물론 프로젝트 자체가 크기 때문에 결정 횟수의 절대적인 수가 작은 것은 아니다.</p>
<h2>오늘 첫 번째 작업: Labor0</h2>
<p>오늘은 먼저 Labor0를 위한 PRD 세 개를 작성했다. PRD를 작성할 때는 GPT 5.6 Sol을 사용한다.</p>
<p>첫 번째는 Devin의 Knowledge 시스템과 비슷한 자동 학습 기능에 관한 PRD였다. 두 번째는 데스크탑과 Apple Watch 앱에서 사용할 음성 조작 기능에 관한 것이었다. 세 번째는 Slack과 Discord 연동을 강화하기 위한 비교적 큰 리팩터링이었다. Labor0의 작업 상태가 해당 메신저의 해당 스레드 안에서 자연스럽게 갱신되도록 만드는 작업이다.</p>
<p>이 가운데 메신저 연동 개선은 구현을 시작했고, 나머지 두 개는 아직 PRD만 작성했다.</p>
<p>Labor0는 24시간 돌아가는 소프트웨어 팩토리에 가깝다. 실제로 Labor0 자체 개발을 위한 세션만 평소 약 10개가 계속 실행되며 토큰을 사용한다. 그만큼 비용도 상당하다. 그래서 필요성이 확정된 작업부터 구현을 시작한다.</p>
<p>PRD는 단순한 문서가 아니다. 무엇을 만들지 결정하고, 아직 만들 필요가 없는 작업에는 토큰을 쓰지 않도록 경계를 세우는 역할도 한다.</p>
<h2>두 번째 작업: Watchtower</h2>
<p>그다음에는 Watchtower를 작업했다.</p>
<p>Watchtower는 Sentry와 호환되는 에러 모니터링 및 관측 시스템으로, 현재 Build in Public 방식으로 개발하고 있다. Watchtower 역시 Labor0와 마찬가지로 스펙 주도 개발 방식을 사용하며 Codex 자동 리뷰를 적극적으로 활용한다.</p>
<p>오늘은 Write PRD 스킬을 사용해 <a href="https://github.com/ZephyrCloudIO/watchtower/issues/13">Watchtower 이슈 #13</a>을 작성했다.</p>
<p>PRD를 만드는 과정에서 통신 방식에 관한 결정을 내려야 했다. 나는 강타입을 좋아해서 Connect RPC를 사용하고 싶었다. 그런데 대화 과정에서는 JSON과 HTTP 기반으로 가는 것이 권장됐다.</p>
<p>몇 차례 더 대화하면서 심각한 기술적 제약이 있는지 확인했다. 살펴보니 본질적인 문제라기보다 Protobuf와 관련 도구의 Rust 지원이 주된 이유였다. 그래서 필요한 것이 있다면 우리가 직접 구현하기로 하고, Protobuf와 HTTP를 사용하기로 결정했다. Connect는 스트리밍이 필요해지는 시점에 도입하기로 했다.</p>
<p>완성된 PRD는 Labor0를 통해 <a href="https://github.com/ZephyrCloudIO/watchtower/pull/31">PR #31</a>로 바뀌었고, 오늘 바로 검토해서 머지했다.</p>
<h2>세 번째 작업: SWC</h2>
<p>마지막으로 SWC를 작업했다.</p>
<p>Codex 데스크탑 앱에서 GPT 6 Astra를 사용해 ES minifier의 모든 파일을 검사하도록 요청했다. 실제로 사용한 프롬프트는 다음과 같다.</p>
<blockquote>
<p>서브에이전트 적극적으로 활용해. ES minifier의 모든 파일 검사해줘. 할 일은 각 파일의 모든 분기 따져보고 각각에 대해서 혹시나 잘못된 조건이 있는지 검사하고, 혹시나 잘못된 조건이 있으면 예시 입력값 만들어서 $add-issue 해주는거야</p>
</blockquote>
<p>Codex는 버그를 발견하면 <code>$add-issue</code> 스킬을 사용해 GitHub 이슈로 남겼다. 그 결과 오늘 하루 동안 46개의 버그를 찾았다.</p>
<p>그다음 <a href="https://labor0.com">Labor0</a>에 한 문장을 입력했다.</p>
<blockquote>
<p>오늘 kdy1이 만든 모든 es/minifier 이슈들 고쳐줘</p>
</blockquote>
<p>46개 이슈는 45개의 Labor0 작업이 됐다. 스코프상 두 이슈를 함께 처리하는 편이 적절하다고 판단된 작업이 하나 있었기 때문이다.</p>
<p>45개 작업은 완전히 병렬로 실행됐고, 각각 하나의 PR을 만들어 총 45개의 PR이 열렸다. 작업이 진행되는 동안 나는 상황을 계속 지켜보지 않았다. 폰을 보고 게임을 하며 놀고 있어서, 모든 PR이 열리기까지 정확히 얼마나 걸렸는지도 모른다.</p>
<p>버그 탐색에는 GPT 6 Astra를 사용했지만, 45개 구현 작업을 전부 Astra가 처리한 것은 아니다. 간단한 작업이 많았기 때문에 GPT 5.6 Terra가 많이 사용됐고, 어려운 Premium 작업에는 Astra가 배정됐다.</p>
<p>이 글을 쓰는 시점에는 45개 PR 중 21개가 머지됐다. 닫아야 했던 PR은 없었다. 나머지는 Codex 자동 리뷰와 Labor0의 피드백 반영 루프를 기다리거나, 실패한 CI를 수정하는 중이다.</p>
<p>머지에 필수인 CI가 실패하면 Labor0가 수정한다. 머지 충돌이 생겨도 Labor0가 해결하고 다시 가져온다.</p>
<h2>Codex의 <code>+1</code>을 기다린다</h2>
<p>내가 작업하는 모든 저장소에는 공통된 리뷰 과정이 있다. SWC뿐 아니라 Labor0와 Watchtower에도 같은 방식을 사용한다.</p>
<p>Labor0가 수정 커밋을 올리면 Codex가 다시 자동 리뷰한다. 리뷰 항목이 발견되면 Labor0가 피드백을 반영하고 새 커밋을 올린다. 그러면 Codex가 그 커밋을 다시 리뷰한다.</p>
<p>이 과정은 Codex가 더 이상 리뷰 항목을 찾지 못할 때까지 반복된다. 충분히 리뷰했다고 판단하면 Codex는 PR에 <code>+1</code> 이모지를 남긴다.</p>
<p>저장소 설정에서는 <code>chatgpt-codex-connector</code> 봇이 남긴 리뷰를 자동으로 반영하도록 구성해 두었다. 이 설정 덕분에 리뷰가 나올 때마다 내가 승인하지 않아도 Labor0가 바로 후속 작업을 진행한다. 해당 설정이 없다면 Labor0는 프로젝트 권한이 있는 사람에게 리뷰를 반영할지 물어본다.</p>
<p>나는 <code>+1</code>이 달린 PR만 필터링해 최종 검토 대상으로 본다. 세션을 많이 실행하고 PR을 많이 만들다 보니, 이런 필터가 없으면 검토할 준비가 끝난 PR을 찾는 일 자체가 또 하나의 일이 된다.</p>
<p>SWC에서 머지한 21개 PR도 모두 Codex가 <code>+1</code>을 남긴 뒤 GitHub에서 코드를 직접 검토하고 수동으로 머지했다.</p>
<h2><code>+1</code>은 사람의 승인이 아니다</h2>
<p>Codex가 <code>+1</code>을 남겼다고 해서 PR이 항상 올바른 것은 아니다. 정말 이상한 상태의 PR에도 <code>+1</code>이 달릴 때가 있다.</p>
<p>Codex는 내가 처음에 품었던 의도를 전부 알지 못한 채 리뷰를 시작한다. 그래서 코드만 보고 판단한 결과가 PR의 방향을 완전히 바꾸기도 한다.</p>
<p>한번은 내가 cut-over 마이그레이션을 하려던 PR이 있었다. Codex는 롤백하면 앱 데이터가 망가질 수 있다고 판단했고, 그 우려에 따라 PR의 방향을 바꿨다. Codex가 <code>+1</code>을 남겼을 때에는 그 잘못된 리뷰 내용이 Labor0를 통해 이미 PR에 반영된 상태였다.</p>
<p>나는 최종 검토에서 “이 작업은 cut-over이며 롤백하지 않을 것이니 해당 변경을 되돌려라”라는 리뷰를 남겼다. Labor0가 이를 반영했고, PR은 정상적으로 머지됐다.</p>
<p>그래서 <code>+1</code>은 머지해도 된다는 최종 승인이 아니다. 자동 리뷰 루프가 끝났고 사람이 검토할 차례가 됐다는 신호에 가깝다.</p>
<p>최종 리뷰에서는 AI가 테스트를 지나치게 추가하지 않았는지도 확인한다. AI가 스크립트의 텍스트를 하나씩 매칭하는 식으로 과도하고 취약한 테스트를 만들 때가 있기 때문이다. SWC PR에서는 Codspeed를 확인해 성능 문제가 생기지 않았는지도 꼭 본다.</p>
<p>AI는 자잘한 버그를 자동 리뷰 단계에서 많이 잡아준다. 덕분에 내가 받는 인지 부하는 예전에 혼자 모든 것을 검토하던 때보다 훨씬 작다. 그럼에도 원래 의도, 테스트의 적절성, 성능과 최종 머지 결정은 사람이 책임져야 한다.</p>
<p>토큰을 잔뜩 쓴 PR을 최종적으로 닫아야 할 때도 있다. 그래도 전체적인 효율은 지금 방식이 훨씬 높다. 엄청나게 빠르기 때문이다.</p>
<h2>6개 세션에서 50개가 넘는 세션으로</h2>
<p>예전에는 Claude Code CLI를 사용했다. 당시에는 세션을 6개만 돌려도 매우 피곤했다. 터미널은 원래 병렬 작업을 관리하기 위해 만들어진 UI가 아니어서, 여러 세션 사이를 계속 전환해야 했다.</p>
<p>Codex 데스크탑으로 옮긴 뒤에는 약 15개 세션까지 운영할 수 있었다.</p>
<p>지금은 특정 시점에 Labor0 세션이 50개를 넘어갈 때도 있지만 크게 힘들지 않다. SWC 작업 45개가 병렬로 실행되던 시점에는 Labor0 자체 개발 세션도 약 15개가 돌아가고 있었을 것이다. 두 프로젝트만 합쳐도 동시에 실행되거나 관리 중인 세션이 50개를 넘는다.</p>
<p>그 외에도 <code>typescript-go</code>를 <code>typescript-rust</code>로 포팅하는 프로젝트, Turborepo를 Effect 기반 TypeScript로 포팅하는 프로젝트, 여러 개인 프로젝트를 함께 진행하고 있다.</p>
<p>이 정도의 동시 작업이 가능한 것은 세션 수 자체보다 각 작업의 범위와 결정 사항이 상세하게 정리돼 있기 때문이다. <code>$add-issue</code>와 Write PRD가 큰 역할을 한다.</p>
<h2>작업에 맞춰 모델을 배분한다</h2>
<p>Labor0에서는 작업마다 하네스와 모델을 직접 지정하거나, AI가 난이도에 맞춰 선택하도록 설정할 수 있다. Cheap, Standard, Premium은 난이도에 따라 작업을 배분하기 위한 개념이다.</p>
<p>나는 Codex 리뷰 반영 작업을 Standard 티어로 실행한다. 여기에는 GPT 5.6 Terra나 GLM 5.3을 사용한다. CI 실패 수정과 머지 충돌 해결은 Cheap 티어로 두고 GPT 5.6 Luna의 high 또는 xhigh를 사용한다.</p>
<p>Premium 티어는 공급자에 따라 다르게 구성한다. Codex 기본 공급자에서는 GPT 5.6 Sol을 사용하고, OpenRouter를 연결한 Codex Custom Provider에서는 GLM 5.3 xhigh를 사용한다. SWC 프로젝트에서는 오늘 Astra를 써보고 싶어서 Premium 작업을 GPT 6 Astra로 설정했다.</p>
<p>Labor0와 Watchtower의 하네스도 Codex다. 다만 Labor0의 Codex Custom Provider 기능으로 OpenRouter에 연결하기 때문에 GLM 모델을 선택할 수 있다. 구현 작업은 GPT 5.6 Terra에서 더 가성비가 좋은 GLM 5.3으로 옮기는 중이다. Codex 데스크탑에서 직접 처리하는 잡다한 작업에는 GPT 5.6 Terra를 사용한다.</p>
<p>Labor0 세션은 AWS ECS Fargate의 격리된 환경에서 실행된다. 내 보안 모델에서는 이 격리 덕분에 오픈 모델 사용이 큰 위협이 되지 않는다고 본다.</p>
<p>모든 작업에 가장 비싼 모델을 사용할 필요는 없다. 작업을 충분히 작게 나누고, 상세한 스펙을 주고, 난이도에 맞는 모델을 배정하고, 자동 리뷰 루프를 거치게 하는 것이 내가 현재 사용하는 방식이다.</p>
<h2>이 글은 현재 시점의 기록이다</h2>
<p>Labor0가 더 발전하면 내 개발 프로세스는 또 바뀔 것이라고 생각한다. 그래서 지금의 방식을 기록해두고 싶었다.</p>
<p>나는 AI Native에 가까운 개발자로서 얻은 인사이트를 공유하고 싶다. 원래부터 사람을 돕고 지식을 나누는 일을 좋아했다. 어릴 때부터 후배들을 가르치고 코드를 리뷰하는 일을 많이 했다.</p>
<p>많은 사람이 이 글을 보고 AI 시대에 맞게 개발하는 방법을 각자의 환경에서 배울 수 있었으면 좋겠다.</p>
<p>지금 내가 도달한 결론은 명확하다.</p>
<p>사람은 언제나 병목이다. HITL은 필수지만, 루프에서 사람을 호출하는 횟수는 최소화해야 한다. AI가 작업을 주도하고, 사람은 의도와 결정을 책임진다. 그리고 이 방식을 유지 가능하게 만드는 첫 번째 조건은 언제나 같다.</p>
<p><strong>작업을 충분히 작은 단위로 쪼개는 것.</strong></p>
]]></content:encoded></item><item><title><![CDATA[Humans Are Always the Bottleneck]]></title><description><![CDATA[How I Build Software with Labor0 and Codex]]></description><link>https://kdy1.dev/2026-9-6-humans-are-always-the-bottleneck</link><guid isPermaLink="true">https://kdy1.dev/2026-9-6-humans-are-always-the-bottleneck</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Sun, 06 Sep 2026 05:20:43 GMT</pubDate><content:encoded><![CDATA[<p>Today, a single prompt turned 46 SWC issues into 45 pull requests.</p>
<p>I do not know exactly how long it took. While the work was running, I was looking at my phone and playing games. By the time I checked, the work had already moved on without me.</p>
<p>My name is kdy1. I created SWC, an open-source compiler project, and previously worked at Deno and Vercel. These days, I spend a lot of time building <a href="https://labor0.com">Labor0</a>, along with <a href="https://github.com/ZephyrCloudIO/watchtower">Watchtower</a> and <a href="http://theaiplatform.app/">theaiplatform.app</a> at Zephyr Cloud IO.</p>
<p>My development workflow has changed dramatically over the past few years. I used to do nearly everything myself. Now, almost all of my development work involves Labor0 and Codex automatic review.</p>
<p>I have one rule that shapes the entire process:</p>
<blockquote>
<p>Humans are always the bottleneck.</p>
</blockquote>
<p>Human-in-the-loop is still essential. Decisions must be made by a human, and I still review and merge pull requests myself. But I want the AI to drive the work and call me into the loop as few times as possible.</p>
<p>When Labor0 encounters a decision, it can send me a question through something like a web push notification. Once I answer, it continues. When a PR is ready, I review and merge it, but Labor0 does not need to wait for me before starting the next independent task.</p>
<h2>A day of AI-native development</h2>
<p>On the day I wrote this, I worked on Labor0, Watchtower, and SWC, in that order.</p>
<p>For Labor0, I wrote three PRDs:</p>
<ul>
<li><p>An automatic learning feature similar to Devin’s Knowledge system</p>
</li>
<li><p>Voice controls for desktop and Apple Watch apps</p>
</li>
<li><p>A large refactoring of Labor0’s messenger integration, so that status updates appear naturally inside the corresponding Slack or Discord thread</p>
</li>
</ul>
<p>I started implementing the messenger refactoring. The other two remain PRDs for now.</p>
<p>I always use my <a href="https://github.com/kdy1/kdy1-scripts/tree/f9079364d84a9d3e1eaa1c8b8c9dbc60ee4e46de/skills/write-prd">Write PRD skill</a> when writing a PRD. I use GPT 5.6 Sol for this work.</p>
<p>The skill does not make decisions for me. I make every decision myself. What surprised me, though, is how few decisions I need to make relative to the size of the projects I run. The absolute number is not small because these projects are large, but it is still much lower than I would have expected.</p>
<p>The skill turns PRD writing into a conversation. It identifies decisions that need to be made, and I resolve them.</p>
<p>I saw this clearly while working on Watchtower, a Sentry-compatible error monitoring and observability system that I recently started building in public. Watchtower uses a spec-driven development process.</p>
<p>While writing <a href="https://github.com/ZephyrCloudIO/watchtower/issues/13">PRD #13</a>, I initially wanted to use Connect RPC because I prefer strongly typed systems. JSON over HTTP was recommended instead, so I spent a few rounds of conversation checking whether Connect had a serious limitation.</p>
<p>It turned out that the main concern was Rust support for Protobuf and its surrounding tooling. That was not a fundamental constraint for me. I decided that we could implement what we needed if necessary, so the PRD settled on Protobuf over HTTP. I considered introducing Connect immediately, but decided to wait until we actually need streaming.</p>
<p>That decision was captured in the PRD. Labor0 then turned the PRD into <a href="https://github.com/ZephyrCloudIO/watchtower/pull/31">PR #31</a>, which I reviewed and merged that day.</p>
<p>After Watchtower, I moved on to SWC.</p>
<h2>Finding 46 bugs with GPT 6 Astra</h2>
<p>I wanted to try GPT 6 Astra, so I opened Codex Desktop and gave it this prompt:</p>
<blockquote>
<p>Use subagents aggressively. Inspect every file in the ES minifier. For each file, examine every branch and check whether any condition is incorrect. If you find an incorrect condition, construct an example input and use <a href="https://github.com/kdy1/kdy1-scripts/tree/f9079364d84a9d3e1eaa1c8b8c9dbc60ee4e46de/skills/add-issue">$add-issue</a> to report it.</p>
</blockquote>
<p>This produced 46 GitHub issues.</p>
<p>The <code>$add-issue</code> skill is an important part of the process. A large number of parallel sessions is only useful when every session receives a sufficiently detailed issue. The skill ensures that a bug is supported by evidence and turned into a self-contained, implementation-ready GitHub issue.</p>
<p>Once the issues existed, I gave Labor0 one prompt:</p>
<blockquote>
<p>Fix every es/minifier issue created by kdy1 today.</p>
</blockquote>
<p>Labor0 converted the 46 issues into 45 tasks. One task covered two issues because their scopes belonged together. A Labor0 task generally produces one PR, so those 45 tasks became 45 pull requests.</p>
<p>All 45 tasks ran in parallel. When tasks depend on each other, Labor0 runs them in dependency order, but these tasks could run concurrently.</p>
<p>GPT 6 Astra found the bugs, but it did not implement all 45 fixes. Labor0 assigns models according to task difficulty, and many of these fixes were simple enough to use GPT 5.6 Terra. I had configured the SWC project to use GPT 6 Astra for difficult, Premium-tier work.</p>
<p>At the time of writing, I had merged 21 of the 45 PRs. I had not closed any of them. The remaining PRs were still going through the Codex review loop or waiting for CI failures to be repaired. When a required CI check fails, Labor0 starts work to fix it. It also repairs merge conflicts when they appear.</p>
<h2>AI reviews AI until it runs out of comments</h2>
<p>Codex automatic review is part of my workflow across every repository, including SWC, Watchtower, and Labor0 itself.</p>
<p>Each time Labor0 pushes a fix commit, Codex reviews the PR again. If Codex finds another issue, Labor0 applies the feedback and pushes another commit. Codex reviews that commit, and the loop continues.</p>
<p>When Codex can no longer find another review item, it leaves a <code>+1</code> reaction on the PR.</p>
<p>I configured these repositories so that reviews from the <code>chatgpt-codex-connector</code> bot are applied automatically. Without that setting, Labor0 asks someone with permission on the Labor0 project whether it should apply the review.</p>
<p>Because I run so many sessions and create so many PRs, the <code>+1</code> reaction is also my review queue. I filter for PRs that received a <code>+1</code> and review only those. Otherwise, finding which PRs are ready for final review would itself become a job.</p>
<p>The 21 SWC PRs I merged all went through this process. Codex left a <code>+1</code>, I inspected the code directly on GitHub, and then I merged each PR manually.</p>
<p>This reduces my cognitive load considerably. Codex catches many small bugs before I ever see the code. Compared with reviewing everything alone, I can focus on fewer and more important questions.</p>
<p>But a <code>+1</code> does not mean the PR is correct. It means that Codex has run out of review comments.</p>
<h2>Why a human still has to look</h2>
<p>Codex begins its review without fully knowing my intent. Because of that, it can sometimes push a PR in a completely wrong direction.</p>
<p>In one migration PR, I wanted a cut-over migration with no rollback path. Codex was concerned that rolling the migration back could damage application data, so it changed the direction of the PR. Labor0 automatically applied that review, and Codex eventually left a <code>+1</code> on the result.</p>
<p>When I performed the final review, the PR was no longer implementing what I wanted.</p>
<p>I left another review explaining that this was a cut-over migration, that we would not roll it back, and that the previous change should be reverted. Labor0 applied my feedback, and the PR was eventually merged successfully.</p>
<p>I also check whether the AI has added too many tests. It tends to go too far. I have seen it add tests that inspect a script by matching its text piece by piece. Tests like that add volume without necessarily improving confidence.</p>
<p>For SWC, I also use Codspeed during final review and always check whether a change introduces a performance problem.</p>
<p>My final review therefore focuses on things that automatic review can still miss:</p>
<ul>
<li><p>Whether the implementation matches the original intent</p>
</li>
<li><p>Whether the PR has moved in an unnecessary or incorrect direction</p>
</li>
<li><p>Whether the tests are excessive or overly tied to implementation details</p>
</li>
<li><p>Whether an SWC change causes a performance regression</p>
</li>
<li><p>Whether I am personally willing to merge the result</p>
</li>
</ul>
<p>The AI can remove a great deal of routine review work, but the final judgment still belongs to me.</p>
<h2>Small tasks are the foundation</h2>
<p>My first rule when assigning work to AI is to split it into sufficiently small units.</p>
<p>Large PRs are difficult for both humans and AI to review, and review quality falls as the PR grows. Before AI coding tools existed, GitHub recorded more than 5,000 PR reviews from me in a single year. After doing that much review, I came to believe very strongly in keeping PRs small.</p>
<p>I suspect AI review quality also declines partly because of context size, although that is my guess rather than a confirmed explanation.</p>
<p>When Labor0 receives a large task, it breaks the work into smaller tasks and produces multiple PRs. It also represents dependencies between those tasks and executes them in the required order.</p>
<p>Detailed issues and PRDs make this possible. <code>$add-issue</code> produces well-defined bug reports. Write PRD helps me resolve decisions before implementation begins. Labor0 can then distribute those bounded tasks across many sessions.</p>
<p>This is the process I think maintainable vibe coding requires: small tasks, explicit decisions, detailed handoffs, independent PRs, and continuous review. Labor0 is my attempt to turn that process into a platform.</p>
<h2>From six terminal sessions to more than fifty</h2>
<p>I used Claude Code CLI in the past. Even six concurrent sessions made me very tired because a terminal was not designed as a UI for managing parallel work. I had to keep switching between sessions.</p>
<p>After moving to Codex Desktop, I could manage around 15 sessions.</p>
<p>With Labor0, there are moments when I have more than 50 sessions active across my projects without feeling particularly overwhelmed. Labor0 development alone commonly keeps around ten sessions consuming tokens around the clock. During the SWC run, I think Labor0 itself had around 15 active sessions. Combined with the SWC work, those two projects alone pushed the total beyond 50.</p>
<p>And those are not my only projects. I also run projects that port <code>typescript-go</code> to <code>typescript-rust</code>, port Turborepo to Effect-based TypeScript, and work on various personal projects.</p>
<p>The number of sessions is possible because the issues are detailed and the work is divided. Concurrency without clear scope would only create more things for me to untangle.</p>
<h2>Routing models by cost and difficulty</h2>
<p>Labor0 can assign a harness and model directly for each task, or allow AI to select them according to difficulty. Cheap, Standard, and Premium are the tiers Labor0 uses for this routing.</p>
<p>I currently use the Standard tier for applying review feedback, with GPT 5.6 Terra or GLM 5.3. CI repairs and merge-conflict resolution use the Cheap tier, with GPT 5.6 Luna at high or xhigh reasoning.</p>
<p>With the regular Codex provider, my Premium tier uses GPT 5.6 Sol. When I connect OpenRouter through Labor0’s Codex Custom Provider, Premium uses GLM 5.3 xhigh. Labor0 and Watchtower both use the Codex harness with this Custom Provider setup, which is how I can select GLM models.</p>
<p>For implementation through Labor0, I have been moving from GPT 5.6 Terra toward the more cost-efficient GLM 5.3. When I work directly in Codex Desktop, I still use GPT 5.6 Terra for miscellaneous tasks.</p>
<p>Labor0 sessions run in isolated environments on AWS ECS Fargate. In my security model, that isolation means using open models presents relatively little additional threat.</p>
<p>Cost still matters. Labor0 feels like a software factory that can operate 24/7, and a factory running 24/7 consumes a lot of tokens. That is why I do not immediately implement every PRD. Once I know that a feature is necessary, I start implementation. Until then, the detailed PRD is enough.</p>
<h2>This workflow will change again</h2>
<p>I expect my development process to change again as Labor0 improves. That is one reason I wanted to write this down: it is a record of how I work at this particular moment.</p>
<p>I also want to share what I have learned as someone getting closer to being an AI-native developer. I have always enjoyed helping people and sharing what I know. Since I was young, I have taught junior developers, reviewed their code, and helped in whatever ways I could.</p>
<p>I hope more developers can look at workflows like this and learn how development can work in this era.</p>
<p>The human is still the bottleneck. My goal is to spend that limited human attention on decisions, intent, and final judgment—and let the software factory handle as much of the rest as possible.</p>
]]></content:encoded></item><item><title><![CDATA[Labor0를 만든 이유]]></title><description><![CDATA[AI 에이전트 세션을 많이 실행하는 것 자체는 어렵지 않다. 내가 해결하고 싶었던 문제는 세션이 늘어날 때마다 사람이 모든 진행 상황을 확인하고 관리해야 한다는 점이었다. 사람을 병목에서 완전히 빼는 게 목표는 아니다. 사람은 여전히 병목이다. 대신 사람이 개입해야 하는 횟수를…]]></description><link>https://kdy1.dev/2026-8-22-labor0</link><guid isPermaLink="true">https://kdy1.dev/2026-8-22-labor0</guid><category><![CDATA[Labor0]]></category><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Sat, 22 Aug 2026 14:07:50 GMT</pubDate><content:encoded><![CDATA[<h2>사람이 병목이 되는 횟수를 줄이기</h2>
<p>AI 에이전트 세션을 많이 실행하는 것 자체는 어렵지 않다. 내가 해결하고 싶었던 문제는 세션이 늘어날 때마다 사람이 모든 진행 상황을 확인하고 관리해야 한다는 점이었다.</p>
<p>사람을 병목에서 완전히 빼는 게 목표는 아니다. 사람은 여전히 병목이다. 대신 사람이 개입해야 하는 횟수를 줄이고, 실제로 결정이 필요한 순간에만 사람을 부르는 구조를 만드는 게 중요하다.</p>
<p>나는 이를 위한 작업 체계를 만들었고, 그 중심에 <a href="https://labor0.com">Labor0</a>가 있다. 한때 50개가 넘는 세션이 돌아갈 때도 내가 느끼는 인지 부하는 거의 없었다.</p>
<p>큰 작업을 맡기면 AI가 먼저 적당한 크기로 나누고, 나뉜 작업의 진행을 주도했다. 작업을 적절한 크기로 나누는 것은 중요하다. PR이 너무 크면 제목만 보고 내용을 파악하기 어렵고, 사람이 직접 리뷰하기도 힘들다. Codex 자동 리뷰의 성능도 떨어진다.</p>
<p>나는 작업이 진행되는 모든 과정에 개입하지 않았다. 결정이 필요한 순간에만 호출받았고, Labor0의 PR 처리와 Codex 자동 리뷰가 모두 끝난 뒤에 PR을 확인했다.</p>
<p>여기서 PR 처리란 CI 실패 수정, 머지 충돌 해결, 리뷰 내용 반영을 말한다. 일부 PR은 나도 코드를 직접 리뷰했다.</p>
<p>안정성을 확보하기 위해 자동화 테스트에도 집중했다. 자동화 테스트에 빈틈이 없는지는 Codex를 활용해 다시 검증했다.</p>
<h2>에이전트가 이어서 일할 수 있는 이슈 만들기</h2>
<p>모든 프로젝트에서는 GitHub를 이슈 관리 도구로 사용했다. 이슈를 만드는 일도 에이전트에 맡겼다.</p>
<p>이를 위해 <code>add-issue</code>라는 전용 스킬을 만들었다. GitHub 이슈만 읽어도 문제를 고칠 수 있을 만큼 상세하게 작성하는 것이 이 스킬의 핵심이었다.</p>
<p><code>add-issue</code>는 같은 내용의 이슈가 이미 있는지 확인하고, <code>main</code> 브랜치와 배포된 버전도 검사한다. 최신 <code>main</code>에서도 아직 고쳐지지 않은 문제일 때만 이슈를 남긴다. 개인정보 등이 이슈에 노출되지 않도록 가리는 기능도 넣었다.</p>
<p>이슈를 남길 때는 Codex 데스크톱 앱의 워크트리 기능을 활용했다. 여러 작업을 서로 다른 워크트리에서 병렬로 진행해 이슈를 동시에 만들었다.</p>
<p>이런 방식으로 작업 속도를 높이는 데에는 많은 토큰이 필요했다. 토큰 사용량은 상당했지만, 토큰 비용은 인건비와 비교하면 매우 저렴하다고 생각한다. 같은 업무를 사람만으로 처리했다면 비용이 30배는 더 들었을 것으로 본다.</p>
<h2>프로덕션 장애로 확인한 차이</h2>
<p>Labor0를 개발하다가 실수로 프로덕션을 중단시킨 적이 있다. 당시에는 어쩔 수 없이 로컬 Codex를 사용해 복구에 필요한 작업을 처리했다.</p>
<p>이 과정에서 Labor0로 일할 때가 로컬 Codex를 직접 사용할 때보다 작업 처리 속도가 훨씬 빠르다는 사실을 확인했다. 이제는 Labor0 없이 Codex만 직접 사용하던 방식으로 돌아가기 어렵다.</p>
<p>그만큼 Labor0의 프로덕션 안정성이 중요해졌다. 지금은 그래프 기반 작업 관리자와 러너처럼 Labor0의 기반을 이루는 구성 요소들의 안정성을 높이는 데 많은 투자를 하고 있다. E2E 테스트를 계속 추가하고 있으며, Codex를 활용해 테스트에 남아 있는 허점도 찾고 있다.</p>
<h2>PR 기반 작업에서 보편적인 작업으로</h2>
<p>현재 Labor0가 관리하는 세션은 PR 기반 작업 흐름에 묶여 있다. <code>CodingTask</code>의 성공 기준도 PR이다.</p>
<p>다만 내부 구조는 이미 <code>CodingTask</code>와 <code>AgentTask</code>로 나뉘어 있다. <code>AgentTask</code>는 아직 내부에만 존재하는 개념으로, 에이전트가 수행할 수 있는 모든 종류의 작업을 나타낸다. PR을 기준으로 하는 <code>CodingTask</code>와 달리 별도의 성공 조건을 가진다.</p>
<p>앞으로는 Labor0가 관리하는 세션을 PR 기반 코딩 작업에서 더 보편적인 작업으로 확장할 계획이다.</p>
<p>러너의 지원 범위도 넓히고 있다. 현재 클라우드에서 호스팅되는 Labor0 러너는 리눅스만 지원한다. 로컬 러너를 이용하면 이미 다른 운영체제의 러너를 사용할 수 있으며, 다른 운영체제를 기반으로 하는 클라우드 러너도 고려하고 있다.</p>
<p>시스템이 관리하는 작업 외에 직접 세션을 확인해야 하는 경우도 있었다. 이런 작업 때문에 Codex 데스크톱을 사용해야 했고, 이를 Labor0 안에서 처리하기 위해 <code>Direct Task</code> 기능을 만들었다.</p>
<p><code>Direct Task</code>는 시스템이 관리하지 않는 세션을 직접 만드는 기능이다. 현재 알파 단계이며 아직 공개하지 않았다.</p>
<p>작업이 빠르게 진행되면서 그동안 무엇이 바뀌었는지 파악하기 위한 기능도 필요해졌다. 그래서 만든 것이 <code>Catch-up</code>이다.</p>
<p><code>Catch-up</code>은 내가 마지막으로 업데이트를 확인한 시점부터 현재까지 무엇이 바뀌었는지를 AI가 요약해 주는 기능이다. 이 기능도 현재 알파 단계다.</p>
<h2>사람이 입력하던 프롬프트까지 자동화하기</h2>
<p>지금은 <code>"labor0" 라벨이 붙은 모든 이슈를 고쳐줘</code> 같은 프롬프트를 내가 반복해서 입력해야 한다.</p>
<p>다음 단계는 이런 프롬프트를 직접 입력하는 일까지 줄이는 것이다. 현재 구상하는 방식은 GitHub 이벤트를 감지하고, 특정 검색 조건을 만족하는 이슈를 Labor0의 작업 그래프에 자동으로 추가하는 것이다.</p>
<p>회사와 프로젝트마다 일하는 방식이 크게 다르기 때문에 특정한 작업 방식에만 맞추지는 않을 생각이다. 각 사용자가 자신의 작업 방식에 맞게 조정할 수 있도록 범용적인 형태로 설계할 계획이다.</p>
<p>이 구조는 GitHub 이슈 외의 신호에도 적용할 수 있다. Grafana나 Sentry 같은 런타임 모니터링 도구에서 문제가 발생하면 작업 그래프에 자동으로 작업을 추가할 수 있다.</p>
<p>슬로 쿼리 로그를 분석해 최적화 작업을 만들거나, 메인 브랜치의 CI가 깨졌을 때 이를 고치는 작업을 생성하는 기능도 추가할 예정이다. 필요한 문서 업데이트 작업도 자동으로 만들 계획이다.</p>
<p>이벤트가 발생했을 때뿐만 아니라 정해진 주기에 맞춰 작업을 반복 실행하는 기능도 있다. 이 기능은 현재 알파 단계다.</p>
<h2>QA도 같은 흐름으로</h2>
<p>회사 블로그에는 <a href="https://theaiplatform.app/blog/automating-pull-request-qa-with-codex-desktop/">Codex Desktop으로 매시간 PR QA를 자동화한 과정</a>을 정리한 글도 썼다.</p>
<p>Codex 데스크톱이 매시간 PR 하나를 골라 빌드하고, 실제 앱을 조작해 변경된 흐름을 검사한 뒤, 스크린샷과 함께 GitHub 리뷰를 남기도록 만든 작업이다. 이것도 Codex 데스크톱으로 직접 구성했다.</p>
<p>앞으로는 이런 QA 작업도 Labor0에서 더 쉽게 만들 수 있도록 지원할 예정이다. 이를 위해 준비하고 있는 기능이 <code>Chatty QA</code>다.</p>
<p><code>Chatty QA</code>는 명백히 잘못된 부분을 발견하면 작업 그래프에 추가해 에이전트가 고치게 한다. 디자인에 관한 결정이 필요하면 스크린샷 등 판단에 필요한 자료와 함께 사용자에게 질문한다. 이 기능도 현재 알파 단계다.</p>
<h2>목표</h2>
<p>우선은 내가 해야 했던 일 가운데 디자인에 관한 결정을 제외한 나머지를 Labor0를 통해 자동화하는 것이 목표다.</p>
<p>더 장기적으로는 지금까지 Codex 데스크톱을 사용해야 했던 작업과 번거롭지만 직접 처리해야 했던 대부분의 작업을 Labor0 안에서 훨씬 편하게 처리할 수 있도록 만들 생각이다.</p>
<p>사람을 작업 과정에서 없애려는 것이 아니다. 에이전트가 처리할 수 있는 일은 계속 진행하게 하고, 사람의 결정이 필요한 순간에만 사람을 부르는 시스템을 만드는 것이 목표다.</p>
]]></content:encoded></item><item><title><![CDATA[작업 기록: 자동 QA 구성]]></title><description><![CDATA[최근에 Zephyr Cloud 의 프로젝트에 자동 QA 시스템을 구성했다. 그 작업 기록이다. 원래 이런 작업은 리눅스에서 하는 게 맞다고 생각했다. 그런데 나는 계속 로컬에서 디버깅해야 했고, 개발 흐름상 맥에서 바로 돌릴 수 있어야 했다. 예전에도 자동 QA를 시도한 적은…]]></description><link>https://kdy1.dev/2026-5-14-task-log-auto-qa</link><guid isPermaLink="true">https://kdy1.dev/2026-5-14-task-log-auto-qa</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Wed, 13 May 2026 21:47:17 GMT</pubDate><content:encoded><![CDATA[<p>최근에 Zephyr Cloud 의 프로젝트에 자동 QA 시스템을 구성했다. 그 작업 기록이다.</p>
<hr />
<p>원래 이런 작업은 리눅스에서 하는 게 맞다고 생각했다. 그런데 나는 계속 로컬에서 디버깅해야 했고, 개발 흐름상 맥에서 바로 돌릴 수 있어야 했다.</p>
<p>예전에도 자동 QA를 시도한 적은 있었지만 끝까지 제대로 굴러간 적은 없었다. 그러다가 지난주 중반쯤, “이건 로컬에서부터 디버깅하면 가능하겠다”는 감이 왔다.</p>
<p>실제로 작업을 시작한 건 목요일이었다.</p>
<hr />
<h3>타임라인</h3>
<h4>목요일 — 로컬 자동 QA 재시작</h4>
<p>목요일부터 자동 QA를 다시 구성하기 시작했다.</p>
<p>Codex에게 로컬에서 실행 가능한 스크립트를 짜게 했고, 초기 접근 방식은 Midscene 기반이었다.</p>
<p>앱이 웹 기반이라 자동화 자체는 비교적 쉬운 편이었다.</p>
<p>문제는 Midscene 기반 접근 방식의 특성이었다.</p>
<p>테스트를 실행하면 실제 컴퓨터 화면을 점유했다. 클릭 이벤트를 수행하려면 실제 GUI를 건드려야 했고, 테스트가 도는 동안 컴퓨터를 사실상 사용할 수 없었다.</p>
<p>즉:</p>
<ul>
<li><p>QA는 자동인데</p>
</li>
<li><p>사람은 컴퓨터를 못 쓰는 상태</p>
</li>
</ul>
<p>가 되어버렸다.</p>
<p>이 시점에서 자동 QA의 의미가 꽤 퇴색된다고 느꼈다.</p>
<p>⸻</p>
<h4>금요일 — CDP 기반 백그라운드 자동 QA 성공</h4>
<p>금요일에는 실행 구조를 바꿨다.</p>
<p>핵심은:</p>
<ul>
<li>화면을 점유하지 않고 백그라운드에서 돌리는 것</li>
</ul>
<p>이었다.</p>
<p>여기서 Midscene 기반 접근에서 CDP 기반 구조로 전환했다.</p>
<p>앱이 웹 기반이었기 때문에 CDP를 사용하는 게 잘 맞았고, 브라우저를 직접 제어하면서 백그라운드 실행이 가능해졌다.</p>
<p>다만 단순 브라우저 제어만으로는 부족해서, 판단과 플로우 제어에는 Claude Code를 사용했다.</p>
<p>결과적으로:</p>
<ul>
<li><p>로컬 디버깅 가능</p>
</li>
<li><p>백그라운드 실행 가능</p>
</li>
<li><p>화면 점유 없음</p>
</li>
<li><p>실제 사용자 시나리오 기반 QA 가능</p>
</li>
</ul>
<p>상태까지 도달했다.</p>
<p>그리고 금요일에 처음으로 자동 QA를 끝까지 완주시키는 데 성공했다.</p>
<hr />
<h4>토요일 — CI 연결</h4>
<p>토요일에는 이 QA를 CI에서 실행되도록 연결했다.</p>
<p>아직 레거시 이미지 기반이긴 했지만, 중요한 것은 PR 단위 자동 QA 가 가능해졌다는 점이었다.</p>
<h3>현재 구조</h3>
<p>현재 흐름은 아래처럼 구성되어 있다.</p>
<ol>
<li>PR 작성</li>
</ol>
<p>PR 본문에는 원래 사람이 수동 QA를 할 때 필요한 가이드라인을 적는다.</p>
<p>예를 들면:</p>
<ul>
<li><p>어떤 기능을 확인해야 하는지</p>
</li>
<li><p>어떤 시나리오를 검증해야 하는지</p>
</li>
<li><p>어떤 동작이 기대 결과인지</p>
</li>
</ul>
<p>같은 내용이다.</p>
<p>⸻</p>
<ol>
<li>QA 라벨 부착</li>
</ol>
<p>'needs ai qa' 라벨을 붙이면 깃허브 액션이 이를 감지한다. 그리고 라벨이 붙으면 자동 QA가 시작된다.</p>
<p>⸻</p>
<ol>
<li>CI에서 자동 QA 수행</li>
</ol>
<p>CI 환경에서 자동으로:</p>
<ul>
<li><p>브라우저 실행</p>
</li>
<li><p>시나리오 수행</p>
</li>
<li><p>화면 분석</p>
</li>
<li><p>결과 판별</p>
</li>
</ul>
<p>을 수행한다.</p>
<p>그리고 이 구조의 장점 중 하나는 병렬 처리였다.</p>
<p>PR이 여러 개 열려 있어도 각각 독립적으로 QA를 수행할 수 있다.</p>
<p>사람이 수동 테스트를 하는 구조였다면:</p>
<ul>
<li><p>여러 PR 동시 처리 어려움</p>
</li>
<li><p>컨텍스트 스위칭 발생</p>
</li>
<li><p>반복 작업 증가</p>
</li>
</ul>
<p>문제가 생겼을 텐데, 지금은 그런 부담이 많이 줄었다.</p>
<p>⸻</p>
<ol>
<li>결과 댓글 작성</li>
</ol>
<p>QA가 끝나면 PR에 댓글을 남긴다.</p>
<p>결과는 항목별로:</p>
<ul>
<li><p>PASS</p>
</li>
<li><p>FAIL</p>
</li>
<li><p>INCONCLUSIVE</p>
</li>
</ul>
<p>형태로 정리된다.</p>
<p>그래서 실제로 사람이 확인해야 하는 건:</p>
<ul>
<li><p>실패 항목</p>
</li>
<li><p>애매한 항목</p>
</li>
</ul>
<p>정도로 줄어들었다.</p>
<p>⸻</p>
<p>스크린샷 / 비디오 기록</p>
<p>자동 QA 과정에서:</p>
<ul>
<li><p>스크린샷 저장</p>
</li>
<li><p>비디오 녹화</p>
</li>
</ul>
<p>도 함께 수행한다.</p>
<p>비디오 녹화 기능은 이번 주 수요일(5월 13일)에 추가했다.</p>
<p>기왕 하는 김에 영상도 있으면 좋을 것 같아서 넣었나</p>
]]></content:encoded></item><item><title><![CDATA[성대 행사에 참여했다]]></title><description><![CDATA[어제 성균관대학교에서 열린 간단한 이벤트에 연사로 참여했는데, 질의 응답 시간에 한 얘기들 중 도움이 될만한 것들이 많았다. 귀차니즘을 해결할 수 있다면 글로 정리해서 올릴 것이다. 주제는 개발 지식 / 전공 지식이 필요한가 AI 시대에 필요한 역량 개발 직군의 미래 가 될…]]></description><link>https://kdy1.dev/2026-5-14-skku-event</link><guid isPermaLink="true">https://kdy1.dev/2026-5-14-skku-event</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Wed, 13 May 2026 21:00:13 GMT</pubDate><content:encoded><![CDATA[<p>어제 성균관대학교에서 열린 간단한 이벤트에 연사로 참여했는데, 질의 응답 시간에 한 얘기들 중 도움이 될만한 것들이 많았다. 귀차니즘을 해결할 수 있다면 글로 정리해서 올릴 것이다.</p>
<p>주제는</p>
<ul>
<li><p>개발 지식 / 전공 지식이 필요한가</p>
</li>
<li><p>AI 시대에 필요한 역량</p>
</li>
<li><p>개발 직군의 미래</p>
</li>
</ul>
<p>가 될 것이다.</p>
]]></content:encoded></item><item><title><![CDATA[한국의 학벌에 대한 생각]]></title><description><![CDATA[내 블로그의 제목이 kdy1: The way I think 인만큼 앞으로는 내 생각을 더 자주 올리려고 한다. 한국 기준으로, 학벌은 사람을 볼 때 꽤나 유용한 지표이지만, 절대적이지는 않다. 경험적인 얘기일 뿐이지만, 성균관대학교 자퇴생으로서 느낀 것들이 몇 가지 있다…]]></description><link>https://kdy1.dev/2026-4-4-korean-edu</link><guid isPermaLink="true">https://kdy1.dev/2026-4-4-korean-edu</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Fri, 03 Apr 2026 23:08:31 GMT</pubDate><content:encoded><![CDATA[<p>내 블로그의 제목이 <code>kdy1: The way I think</code> 인만큼 앞으로는 내 생각을 더 자주 올리려고 한다.</p>
<p>한국 기준으로, 학벌은 사람을 볼 때 꽤나 유용한 지표이지만, 절대적이지는 않다. 경험적인 얘기일 뿐이지만, 성균관대학교 자퇴생으로서 느낀 것들이 몇 가지 있다.</p>
<p>대학까지 간 사람의 학벌은 <code>학습 능력 x 성실함</code> 에 <strong>대체로</strong> 비례한다. 그래서 의미가 있는 것 같다. 나도 대학교 덕분에 사람들 큰 걱정 없이 편하게 만날 수 있었다. 근데 <strong>대체로</strong>가 함정인데, 내가 학교를 다니던 시절 기준으론 성대 정도의 학교도 쉽게 들어올 방법이 꽤나 있었고, 그런 경우 저 곱셈식이 어그러져서인지 대체로 문제가 살짝 있었다.</p>
<p>지금 생각해보면 성대의 특성일 수도 있다. 성대생들은 대체로 저 곱셈식에서 성실함의 비중이 꽤 되는 사람들이기 때문이다. 제대로 노력을 해 본 적 없는 사람들은 자기의 주제를 전혀 모르는데, 내 친구들 중엔 그런 사람이 거의 없었다.</p>
]]></content:encoded></item><item><title><![CDATA[Agentic Coding tips 2]]></title><description><![CDATA[This is a translation of I recently gave a short presentation about how I use AI. The first part of the slides overlaps with a previous blog post. In this…]]></description><link>https://kdy1.dev/2026-1-31-ai-coding-tips-en</link><guid isPermaLink="true">https://kdy1.dev/2026-1-31-ai-coding-tips-en</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Fri, 30 Jan 2026 23:32:27 GMT</pubDate><content:encoded><![CDATA[<p>This is a translation of <a target="_blank" href="https://kdy1.dev/2026-1-31-ai-coding-tips-kr">https://kdy1.dev/2026-1-31-ai-coding-tips-kr</a></p>
<hr />
<p>I recently gave a short presentation about how I use AI. The first part of the slides overlaps with a <a target="_blank" href="https://kdy1.dev/2026-1-5-ai-coding-agent-tips">previous blog post</a>. In this article, I’ll focus on topics that weren’t covered in that post.</p>
<h2 id="heading-error-messages-and-logging">Error Messages and Logging</h2>
<h2 id="heading-using-concrete-types-and-schemas">Using Concrete Types and Schemas</h2>
<p>The <code>any</code> type is dangerous even for humans—but it’s even more dangerous for AI.</p>
<p>The same applies to things like:</p>
<ul>
<li><p>Unconstrained parsing such as <code>JSON.parse</code></p>
</li>
<li><p>Loose interfaces</p>
</li>
<li><p>Implicit or undocumented data structures</p>
</li>
</ul>
<p>These patterns force AI to make <strong>too many assumptions</strong>.</p>
<p>The real problem is that once an assumption is wrong, <em>all subsequent reasoning can spiral out of control</em>.</p>
<p>So I try to follow these principles as much as possible:</p>
<ul>
<li><p>Use the most concrete types possible instead of <code>any</code></p>
</li>
<li><p>Prefer schema-based parsers over simple parsing<br />  (e.g., Zod or Yup instead of <code>JSON.parse</code>)</p>
</li>
</ul>
<p>With this approach, even if the AI makes assumptions:</p>
<ul>
<li><p>The probability of those assumptions being wrong is lower</p>
</li>
<li><p>When they <em>are</em> wrong, the system fails fast</p>
</li>
</ul>
<p>In other words, this <strong>prevents AI from carrying incorrect reasoning all the way to the end</strong>.</p>
<h2 id="heading-leveraging-github-actions">Leveraging GitHub Actions</h2>
<p>If you look closely, GitHub Actions has some surprisingly strong properties:</p>
<ul>
<li><p>Completely isolated environments</p>
</li>
<li><p>Easy to configure</p>
</li>
<li><p>A large collection of well-prepared examples</p>
</li>
</ul>
<p>Instead of using it only for CI, I started treating it as a <strong>development virtual machine</strong>.</p>
<p>The same idea applies to AI.</p>
<blockquote>
<p>“Whatever a developer can do locally,<br />AI should be able to do in exactly the same way.”</p>
</blockquote>
<h3 id="heading-setting-up-a-development-environment-for-claude-code">Setting Up a Development Environment for Claude Code</h3>
<ul>
<li>Actual code: <a target="_blank" href="https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude.yml">https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude.yml</a></li>
</ul>
<pre><code class="lang-yaml"><span class="hljs-attr">name:</span> <span class="hljs-string">Claude</span> <span class="hljs-string">Code</span>

<span class="hljs-attr">on:</span>
  <span class="hljs-attr">issue_comment:</span>
    <span class="hljs-attr">types:</span> [<span class="hljs-string">created</span>]
  <span class="hljs-attr">pull_request_review_comment:</span>
    <span class="hljs-attr">types:</span> [<span class="hljs-string">created</span>]
  <span class="hljs-attr">issues:</span>
    <span class="hljs-attr">types:</span> [<span class="hljs-string">opened</span>, <span class="hljs-string">assigned</span>]
  <span class="hljs-attr">pull_request_review:</span>
    <span class="hljs-attr">types:</span> [<span class="hljs-string">submitted</span>]

<span class="hljs-attr">jobs:</span>
  <span class="hljs-attr">claude:</span>
    <span class="hljs-attr">if:</span> <span class="hljs-string">|
      (github.event_name == 'issue_comment' &amp;&amp; contains(github.event.comment.body, '@claude')) ||
      (github.event_name == 'pull_request_review_comment' &amp;&amp; contains(github.event.comment.body, '@claude')) ||
      (github.event_name == 'pull_request_review' &amp;&amp; contains(github.event.review.body, '@claude')) ||
      (github.event_name == 'issues' &amp;&amp; (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
</span>    <span class="hljs-attr">runs-on:</span> <span class="hljs-string">ubuntu-latest</span>
    <span class="hljs-attr">permissions:</span>
      <span class="hljs-attr">contents:</span> <span class="hljs-string">read</span>
      <span class="hljs-attr">pull-requests:</span> <span class="hljs-string">read</span>
      <span class="hljs-attr">issues:</span> <span class="hljs-string">read</span>
      <span class="hljs-attr">id-token:</span> <span class="hljs-string">write</span>
      <span class="hljs-attr">actions:</span> <span class="hljs-string">read</span> <span class="hljs-comment"># Required for Claude to read CI results on PRs</span>
    <span class="hljs-attr">steps:</span>
      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Checkout</span> <span class="hljs-string">repository</span>
        <span class="hljs-attr">uses:</span> <span class="hljs-string">actions/checkout@v4</span>
        <span class="hljs-attr">with:</span>
          <span class="hljs-attr">fetch-depth:</span> <span class="hljs-number">1</span>

      <span class="hljs-comment"># Setup pnpm</span>
      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Setup</span> <span class="hljs-string">pnpm</span>
        <span class="hljs-attr">uses:</span> <span class="hljs-string">pnpm/action-setup@v4.2.0</span>

      <span class="hljs-bullet">-</span> <span class="hljs-attr">uses:</span> <span class="hljs-string">actions/checkout@v4</span>

      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Install</span> <span class="hljs-string">Tauri</span> <span class="hljs-string">dependencies</span>
        <span class="hljs-attr">run:</span> <span class="hljs-string">|
            sudo apt-get update
            sudo apt-get install -y \
              libwebkit2gtk-4.1-dev \
              libappindicator3-dev \
              librsvg2-dev \
              patchelf
</span>
      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Setup</span> <span class="hljs-string">Rust</span>
        <span class="hljs-attr">uses:</span> <span class="hljs-string">dtolnay/rust-toolchain@stable</span>

      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Run</span> <span class="hljs-string">Claude</span> <span class="hljs-string">Code</span>
        <span class="hljs-attr">id:</span> <span class="hljs-string">claude</span>
        <span class="hljs-attr">uses:</span> <span class="hljs-string">anthropics/claude-code-action@v1</span>
        <span class="hljs-attr">with:</span>
          <span class="hljs-attr">claude_code_oauth_token:</span> <span class="hljs-string">${{</span> <span class="hljs-string">secrets.CLAUDE_CODE_OAUTH_TOKEN</span> <span class="hljs-string">}}</span>

          <span class="hljs-comment"># This is an optional setting that allows Claude to read CI results on PRs</span>
          <span class="hljs-attr">additional_permissions:</span> <span class="hljs-string">|
            actions: read
</span>
          <span class="hljs-attr">claude_args:</span> <span class="hljs-string">|
            --allowed-tools Bash,WebFetch,WebSearch,Skill
            --model opus</span>
</code></pre>
<p>With GitHub Actions, you can set things up so that:</p>
<ul>
<li><p>Package managers are installed</p>
</li>
<li><p>Build commands are executed (<code>pnpm build</code>, <code>cargo build</code>, etc.)</p>
</li>
<li><p>Tests are run</p>
</li>
</ul>
<p>Once configured this way, Claude Code effectively operates in an environment that’s <strong>almost identical to a local development setup</strong>.</p>
<p>When the environment is this complete, the quality of AI output improves dramatically:</p>
<ul>
<li><p>It stops guessing</p>
</li>
<li><p>It reasons based on actual execution results</p>
</li>
<li><p>It produces “code that actually runs,” not just “code that should work in theory”</p>
</li>
</ul>
<h3 id="heading-managing-clean-commit-messages-with-ai">Managing Clean Commit Messages with AI</h3>
<p><img src="https://cdn.gamma.app/369hvd746fpmyb6/9780314e609f49c496cb045817adfa33/original/seukeurinsyas-2026-01-30-ohu-5.29.37.png" alt="screenshot" /></p>
<h3 id="heading-preventing-pr-description-spam">Preventing PR Description Spam</h3>
<ul>
<li>Actual code: <a target="_blank" href="https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude-code-review.yml#L34-L55">https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude-code-review.yml#L34-L55</a></li>
</ul>
<pre><code class="lang-yaml"><span class="hljs-attr">name:</span> <span class="hljs-string">Claude</span> <span class="hljs-string">Code</span> <span class="hljs-string">Review</span>

<span class="hljs-attr">on:</span>
  <span class="hljs-attr">pull_request:</span>
    <span class="hljs-attr">types:</span> [<span class="hljs-string">opened</span>, <span class="hljs-string">synchronize</span>]

<span class="hljs-attr">jobs:</span>
  <span class="hljs-attr">claude-review:</span>
    <span class="hljs-attr">runs-on:</span> <span class="hljs-string">ubuntu-latest</span>
    <span class="hljs-attr">permissions:</span>
      <span class="hljs-attr">contents:</span> <span class="hljs-string">read</span>
      <span class="hljs-attr">pull-requests:</span> <span class="hljs-string">write</span>
      <span class="hljs-attr">issues:</span> <span class="hljs-string">read</span>
      <span class="hljs-attr">id-token:</span> <span class="hljs-string">write</span>

    <span class="hljs-attr">steps:</span>
      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Checkout</span> <span class="hljs-string">repository</span>
        <span class="hljs-attr">uses:</span> <span class="hljs-string">actions/checkout@v4</span>
        <span class="hljs-attr">with:</span>
          <span class="hljs-attr">fetch-depth:</span> <span class="hljs-number">1</span>

      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Dismiss</span> <span class="hljs-string">old</span> <span class="hljs-string">Claude</span> <span class="hljs-string">bot</span> <span class="hljs-string">comments</span>
        <span class="hljs-attr">env:</span>
          <span class="hljs-attr">GH_TOKEN:</span> <span class="hljs-string">${{</span> <span class="hljs-string">secrets.GITHUB_TOKEN</span> <span class="hljs-string">}}</span>
        <span class="hljs-attr">run:</span> <span class="hljs-string">|
          REPO="${{ github.repository }}"
          PR_NUMBER="${{ github.event.pull_request.number }}"
</span>
          <span class="hljs-string">gh</span> <span class="hljs-string">api</span> <span class="hljs-string">"repos/$REPO/issues/$PR_NUMBER/comments"</span> <span class="hljs-string">--jq</span> <span class="hljs-string">'.[] | select(.user.login == "claude[bot]") | .node_id'</span> <span class="hljs-string">|</span> <span class="hljs-string">while</span> <span class="hljs-string">read</span> <span class="hljs-string">-r</span> <span class="hljs-string">comment_node_id;</span> <span class="hljs-string">do</span>
            <span class="hljs-string">if</span> [ <span class="hljs-string">-n</span> <span class="hljs-string">"$comment_node_id"</span> ]<span class="hljs-string">;</span> <span class="hljs-string">then</span>
              <span class="hljs-string">gh</span> <span class="hljs-string">api</span> <span class="hljs-string">graphql</span> <span class="hljs-string">-f</span> <span class="hljs-string">query='</span>
                <span class="hljs-string">mutation($id:</span> <span class="hljs-string">ID!)</span> {
                  <span class="hljs-string">minimizeComment(input:</span> {<span class="hljs-attr">subjectId:</span> <span class="hljs-string">$id</span>, <span class="hljs-attr">classifier:</span> <span class="hljs-string">OUTDATED</span>}<span class="hljs-string">)</span> {
                    <span class="hljs-string">minimizedComment</span> {
                      <span class="hljs-string">isMinimized</span>
                    }
                  }
                }<span class="hljs-string">' -f id="$comment_node_id"
            fi
          done

      - name: Run Claude Code Review
        id: claude-review
        uses: anthropics/claude-code-action@v1
        with:
          claude_code_oauth_token: $<span class="hljs-template-variable">{{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}</span>
          allowed_bots: '</span><span class="hljs-string">*'</span>
          <span class="hljs-attr">prompt:</span> <span class="hljs-string">|
            REPO: ${{ github.repository }}
            PR NUMBER: ${{ github.event.pull_request.number }}
</span>
            <span class="hljs-attr">Please review this pull request and provide feedback on:</span>
            <span class="hljs-bullet">-</span> <span class="hljs-string">Code</span> <span class="hljs-string">quality</span> <span class="hljs-string">and</span> <span class="hljs-string">best</span> <span class="hljs-string">practices</span>
            <span class="hljs-bullet">-</span> <span class="hljs-string">Potential</span> <span class="hljs-string">bugs</span> <span class="hljs-string">or</span> <span class="hljs-string">issues</span>
            <span class="hljs-bullet">-</span> <span class="hljs-string">Performance</span> <span class="hljs-string">considerations</span>
            <span class="hljs-bullet">-</span> <span class="hljs-string">Security</span> <span class="hljs-string">concerns</span>
            <span class="hljs-bullet">-</span> <span class="hljs-string">Test</span> <span class="hljs-string">coverage</span>

            <span class="hljs-string">Use</span> <span class="hljs-string">the</span> <span class="hljs-string">repository's</span> <span class="hljs-string">CLAUDE.md</span> <span class="hljs-string">for</span> <span class="hljs-string">guidance</span> <span class="hljs-string">on</span> <span class="hljs-string">style</span> <span class="hljs-string">and</span> <span class="hljs-string">conventions.</span> <span class="hljs-string">Be</span> <span class="hljs-string">constructive</span> <span class="hljs-string">and</span> <span class="hljs-string">helpful</span> <span class="hljs-string">in</span> <span class="hljs-string">your</span> <span class="hljs-string">feedback.</span>

            <span class="hljs-string">Use</span> <span class="hljs-string">`gh</span> <span class="hljs-string">pr</span> <span class="hljs-string">comment`</span> <span class="hljs-string">with</span> <span class="hljs-string">your</span> <span class="hljs-string">Bash</span> <span class="hljs-string">tool</span> <span class="hljs-string">to</span> <span class="hljs-string">leave</span> <span class="hljs-string">your</span> <span class="hljs-string">review</span> <span class="hljs-string">as</span> <span class="hljs-string">a</span> <span class="hljs-string">comment</span> <span class="hljs-string">on</span> <span class="hljs-string">the</span> <span class="hljs-string">PR.</span>

          <span class="hljs-attr">claude_args:</span> <span class="hljs-string">'--allowed-tools "Bash(gh issue view:*),Bash(gh search:*),Bash(gh issue list:*),Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*),Bash(gh pr list:*)"'</span>
</code></pre>
<p>There’s one bug in the Claude Code GitHub review action: <strong>it leaves too many review comments</strong>.</p>
<p>This can easily result in PRs being flooded with AI-generated comments.</p>
<h2 id="heading-how-to-use-ai-reviews-effectively">How to Use AI Reviews Effectively</h2>
<h3 id="heading-core-assumptions">Core Assumptions</h3>
<p>Let’s be explicit about the premises:</p>
<ul>
<li><p>Human reviews are slow</p>
</li>
<li><p>Human reviews are expensive</p>
</li>
</ul>
<p>Therefore, the goal is to <strong>minimize human involvement</strong>.</p>
<p>The strategy I chose is:</p>
<ol>
<li><p>Run AI reviews and CI first</p>
</li>
<li><p>Humans do not intervene until AI gives an OK</p>
</li>
<li><p>Only when tests and automated reviews pass</p>
</li>
<li><p>A human performs the final review</p>
</li>
</ol>
<p>In short:</p>
<blockquote>
<p>Humans act only as the “final approver.”</p>
</blockquote>
<h3 id="heading-1-using-a-github-app">1. Using a GitHub App</h3>
<p>By integrating AI reviews as a GitHub App, reviews start automatically as soon as a PR is opened.</p>
<p>At this stage, AI filters out:</p>
<ul>
<li><p>Code style issues</p>
</li>
<li><p>Obvious bugs</p>
</li>
<li><p>Structural problems</p>
</li>
</ul>
<h3 id="heading-2-applying-changes-via-github-actions">2. Applying Changes via GitHub Actions</h3>
<p><img src="https://cdn.gamma.app/369hvd746fpmyb6/9151ee873c544e18a87b6143de64214c/original/image.png" alt="screenshot" /></p>
<p>Using tools like the Claude Code GitHub Action makes parallel processing much easier. Checking out code locally should be reserved for situations where human, local testing is truly required.</p>
<h3 id="heading-3-using-ci-as-a-gatekeeper">3. Using CI as a Gatekeeper</h3>
<p><img src="https://cdn.gamma.app/369hvd746fpmyb6/5afe35a1a3714b81976456d41f3bbdcb/original/seukeurinsyas-2026-01-30-ohu-5.33.30.png" alt="screenshot" /></p>
<p>The key is to treat CI not just as a testing tool, but as:</p>
<blockquote>
<p><strong>A barrier between AI and humans</strong></p>
</blockquote>
<p>If AI-generated changes can’t pass CI, they never reach human reviewers. That alone significantly reduces review costs.</p>
<hr />
<h2 id="heading-qampa">Q&amp;A</h2>
<h3 id="heading-why-mcp-is-unnecessary-for-this-use-case">Why MCP Is Unnecessary for This Use Case</h3>
<p>Imagine there is a CLI that provides the exact same capabilities as a specific MCP server. Anything you can do through MCP could also be done through that CLI. This is why Vercel chose to improve its CLI instead of building an MCP server.</p>
]]></content:encoded></item><item><title><![CDATA[Ai 코딩 팁 2 (한국어)]]></title><description><![CDATA[AI 활용법 관련해서 간단하게 발표를 했다. 발표 자료 앞쪽은 전에 블로그에 올린 글이랑 같은 내용이다. 이 글에서는 기존 글에서 다루지 않은 내용들을 다루겠다. any 타입은 사람에게도 위험하지만, AI에게는 더 위험하다. 마찬가지로, JSON.parse처럼 아무 제약 없는…]]></description><link>https://kdy1.dev/2026-1-31-ai-coding-tips-kr</link><guid isPermaLink="true">https://kdy1.dev/2026-1-31-ai-coding-tips-kr</guid><dc:creator><![CDATA[DongYun Kang]]></dc:creator><pubDate>Fri, 30 Jan 2026 23:31:14 GMT</pubDate><content:encoded><![CDATA[<ul>
<li>발표 자료: <a target="_blank" href="https://gamma.app/docs/AI--2a52e7tk3eb1ch1">https://gamma.app/docs/AI--2a52e7tk3eb1ch1</a></li>
</ul>
<p>AI 활용법 관련해서 간단하게 발표를 했다. 발표 자료 앞쪽은 <a target="_blank" href="https://kdy1.dev/2026-1-5-ai-coding-agent-tips">전에 블로그에 올린 글</a>이랑 같은 내용이다. 이 글에서는 기존 글에서 다루지 않은 내용들을 다루겠다.</p>
<h2 id="heading-7jeq65siouploylnoyngcdrsi8g66gc6rmf">에러 메시지 및 로깅</h2>
<h2 id="heading-6rws7lk07kcbio2dgoyehsdrsi8g7iqk7ykk66eiio2znoyaqq">구체적 타입 및 스키마 활용</h2>
<p><code>any</code> 타입은 사람에게도 위험하지만, AI에게는 더 위험하다.</p>
<p>마찬가지로,</p>
<ul>
<li><p><code>JSON.parse</code>처럼 아무 제약 없는 파싱</p>
</li>
<li><p>느슨한 인터페이스</p>
</li>
<li><p>암묵적인 데이터 구조</p>
</li>
</ul>
<p>이런 것들은 AI가 <strong>너무 많은 가정을 하게 만든다</strong>.</p>
<p>문제는 그 가정이 틀리면, 이후의 모든 판단이 연쇄적으로 꼬인다는 점이다.</p>
<p>그래서 가능한 한 다음을 지향한다.</p>
<ul>
<li><p><code>any</code> 타입 대신 최대한 구체적인 타입 사용</p>
</li>
<li><p>단순 파싱 대신 스키마 기반 파서 사용<br />  (예: <code>JSON.parse</code> 대신 Zod, Yup 같은 라이브러리)</p>
</li>
</ul>
<p>이렇게 하면 AI가 가정을 하더라도,</p>
<ul>
<li><p>그 가정이 틀릴 확률이 줄어들고</p>
</li>
<li><p>틀렸을 경우 즉시 실패하도록 만들 수 있다</p>
</li>
</ul>
<p>즉, <strong>AI가 잘못된 추론을 끝까지 끌고 가는 상황을 예방</strong>할 수 있다.</p>
<h2 id="heading-github-actions">GitHub Actions 활용</h2>
<p>GitHub Actions를 잘 보면 꽤 괜찮은 특징을 갖고 있다.</p>
<ul>
<li><p>완전히 격리된 환경</p>
</li>
<li><p>구성하기 쉬움</p>
</li>
<li><p>이미 잘 구성된 예제가 많음</p>
</li>
</ul>
<p>이걸 단순히 CI 용도로만 쓰지 않고,<br /><strong>개발용 가상 머신</strong>처럼 사용하는 접근을 했다.</p>
<p>AI에게도 마찬가지다.</p>
<blockquote>
<p>“로컬에서 개발자가 할 수 있는 걸<br />AI도 똑같이 할 수 있게 만들어준다”</p>
</blockquote>
<p>라는 관점이다.</p>
<h3 id="heading-claude-code">Claude Code를 위한 개발 환경 구성</h3>
<ul>
<li>실제 코드: <a target="_blank" href="https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude.yml">https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude.yml</a></li>
</ul>
<pre><code class="lang-yaml"><span class="hljs-attr">name:</span> <span class="hljs-string">Claude</span> <span class="hljs-string">Code</span>

<span class="hljs-attr">on:</span>
  <span class="hljs-attr">issue_comment:</span>
    <span class="hljs-attr">types:</span> [<span class="hljs-string">created</span>]
  <span class="hljs-attr">pull_request_review_comment:</span>
    <span class="hljs-attr">types:</span> [<span class="hljs-string">created</span>]
  <span class="hljs-attr">issues:</span>
    <span class="hljs-attr">types:</span> [<span class="hljs-string">opened</span>, <span class="hljs-string">assigned</span>]
  <span class="hljs-attr">pull_request_review:</span>
    <span class="hljs-attr">types:</span> [<span class="hljs-string">submitted</span>]

<span class="hljs-attr">jobs:</span>
  <span class="hljs-attr">claude:</span>
    <span class="hljs-attr">if:</span> <span class="hljs-string">|
      (github.event_name == 'issue_comment' &amp;&amp; contains(github.event.comment.body, '@claude')) ||
      (github.event_name == 'pull_request_review_comment' &amp;&amp; contains(github.event.comment.body, '@claude')) ||
      (github.event_name == 'pull_request_review' &amp;&amp; contains(github.event.review.body, '@claude')) ||
      (github.event_name == 'issues' &amp;&amp; (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
</span>    <span class="hljs-attr">runs-on:</span> <span class="hljs-string">ubuntu-latest</span>
    <span class="hljs-attr">permissions:</span>
      <span class="hljs-attr">contents:</span> <span class="hljs-string">read</span>
      <span class="hljs-attr">pull-requests:</span> <span class="hljs-string">read</span>
      <span class="hljs-attr">issues:</span> <span class="hljs-string">read</span>
      <span class="hljs-attr">id-token:</span> <span class="hljs-string">write</span>
      <span class="hljs-attr">actions:</span> <span class="hljs-string">read</span> <span class="hljs-comment"># Required for Claude to read CI results on PRs</span>
    <span class="hljs-attr">steps:</span>
      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Checkout</span> <span class="hljs-string">repository</span>
        <span class="hljs-attr">uses:</span> <span class="hljs-string">actions/checkout@v4</span>
        <span class="hljs-attr">with:</span>
          <span class="hljs-attr">fetch-depth:</span> <span class="hljs-number">1</span>

      <span class="hljs-comment"># Setup pnpm </span>
      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Setup</span> <span class="hljs-string">pnpm</span>
        <span class="hljs-attr">uses:</span> <span class="hljs-string">pnpm/action-setup@v4.2.0</span>

      <span class="hljs-bullet">-</span> <span class="hljs-attr">uses:</span> <span class="hljs-string">actions/checkout@v4</span>

      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Install</span> <span class="hljs-string">Tauri</span> <span class="hljs-string">dependencies</span>
        <span class="hljs-attr">run:</span> <span class="hljs-string">|
            sudo apt-get update
            sudo apt-get install -y \
              libwebkit2gtk-4.1-dev \
              libappindicator3-dev \
              librsvg2-dev \
              patchelf
</span>
      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Setup</span> <span class="hljs-string">Rust</span>
        <span class="hljs-attr">uses:</span> <span class="hljs-string">dtolnay/rust-toolchain@stable</span>

      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Run</span> <span class="hljs-string">Claude</span> <span class="hljs-string">Code</span>
        <span class="hljs-attr">id:</span> <span class="hljs-string">claude</span>
        <span class="hljs-attr">uses:</span> <span class="hljs-string">anthropics/claude-code-action@v1</span>
        <span class="hljs-attr">with:</span>
          <span class="hljs-attr">claude_code_oauth_token:</span> <span class="hljs-string">${{</span> <span class="hljs-string">secrets.CLAUDE_CODE_OAUTH_TOKEN</span> <span class="hljs-string">}}</span>

          <span class="hljs-comment"># This is an optional setting that allows Claude to read CI results on PRs</span>
          <span class="hljs-attr">additional_permissions:</span> <span class="hljs-string">|
            actions: read
</span>
          <span class="hljs-attr">claude_args:</span> <span class="hljs-string">|
            --allowed-tools Bash,WebFetch,WebSearch,Skill
            --model opus</span>
</code></pre>
<p>GitHub Actions에서:</p>
<ul>
<li><p>패키지 매니저 설치</p>
</li>
<li><p>빌드 명령 실행 (<code>pnpm build</code>, <code>cargo build</code> 등)</p>
</li>
<li><p>테스트 실행</p>
</li>
</ul>
<p>까지 모두 가능하게 구성해두면,<br />Claude Code는 사실상 <strong>로컬 개발 환경과 거의 동일한 조건</strong>에서 동작한다.</p>
<p>이렇게 환경이 갖춰져 있으면 AI의 작업 품질이 눈에 띄게 좋아진다.</p>
<ul>
<li><p>추측으로 답하지 않고</p>
</li>
<li><p>실제 실행 결과를 기반으로 판단하고</p>
</li>
<li><p>“이론상 맞는 코드” 대신 “실제로 도는 코드”를 만든다</p>
</li>
</ul>
<h3 id="heading-ai">AI로 커밋 메시지 예쁘게 관리하기</h3>
<p><img src="https://cdn.gamma.app/369hvd746fpmyb6/9780314e609f49c496cb045817adfa33/original/seukeurinsyas-2026-01-30-ohu-5.29.37.png" alt /></p>
<h3 id="heading-pr">PR 본문 스팸 방지</h3>
<ul>
<li>실제 코드: <a target="_blank" href="https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude-code-review.yml#L34-L55">https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude-code-review.yml#L34-L55</a></li>
</ul>
<pre><code class="lang-yaml"><span class="hljs-attr">name:</span> <span class="hljs-string">Claude</span> <span class="hljs-string">Code</span> <span class="hljs-string">Review</span>

<span class="hljs-attr">on:</span>
  <span class="hljs-attr">pull_request:</span>
    <span class="hljs-attr">types:</span> [<span class="hljs-string">opened</span>, <span class="hljs-string">synchronize</span>]
    <span class="hljs-comment"># Optional: Only run on specific file changes</span>
    <span class="hljs-comment"># paths:</span>
    <span class="hljs-comment">#   - "src/**/*.ts"</span>
    <span class="hljs-comment">#   - "src/**/*.tsx"</span>
    <span class="hljs-comment">#   - "src/**/*.js"</span>
    <span class="hljs-comment">#   - "src/**/*.jsx"</span>

<span class="hljs-attr">jobs:</span>
  <span class="hljs-attr">claude-review:</span>
    <span class="hljs-comment"># Optional: Filter by PR author</span>
    <span class="hljs-comment"># if: |</span>
    <span class="hljs-comment">#   github.event.pull_request.user.login == 'external-contributor' ||</span>
    <span class="hljs-comment">#   github.event.pull_request.user.login == 'new-developer' ||</span>
    <span class="hljs-comment">#   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'</span>

    <span class="hljs-attr">runs-on:</span> <span class="hljs-string">ubuntu-latest</span>
    <span class="hljs-attr">permissions:</span>
      <span class="hljs-attr">contents:</span> <span class="hljs-string">read</span>
      <span class="hljs-attr">pull-requests:</span> <span class="hljs-string">write</span>
      <span class="hljs-attr">issues:</span> <span class="hljs-string">read</span>
      <span class="hljs-attr">id-token:</span> <span class="hljs-string">write</span>

    <span class="hljs-attr">steps:</span>
      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Checkout</span> <span class="hljs-string">repository</span>
        <span class="hljs-attr">uses:</span> <span class="hljs-string">actions/checkout@v4</span>
        <span class="hljs-attr">with:</span>
          <span class="hljs-attr">fetch-depth:</span> <span class="hljs-number">1</span>

      <span class="hljs-bullet">-</span> <span class="hljs-attr">name:</span> <span class="hljs-string">Dismiss</span> <span class="hljs-string">old</span> <span class="hljs-string">Claude</span> <span class="hljs-string">bot</span> <span class="hljs-string">comments</span>
        <span class="hljs-attr">env:</span>
          <span class="hljs-attr">GH_TOKEN:</span> <span class="hljs-string">${{</span> <span class="hljs-string">secrets.GITHUB_TOKEN</span> <span class="hljs-string">}}</span>
        <span class="hljs-attr">run:</span> <span class="hljs-string">|
          # Get PR comments from claude[bot] and hide them as outdated
          REPO="${{ github.repository }}"
          PR_NUMBER="${{ github.event.pull_request.number }}"
</span>
          <span class="hljs-comment"># Get issue comments (gh pr comment creates issue comments, not review comments)</span>
          <span class="hljs-string">gh</span> <span class="hljs-string">api</span> <span class="hljs-string">"repos/$REPO/issues/$PR_NUMBER/comments"</span> <span class="hljs-string">--jq</span> <span class="hljs-string">'.[] | select(.user.login == "claude[bot]") | .node_id'</span> <span class="hljs-string">|</span> <span class="hljs-string">while</span> <span class="hljs-string">read</span> <span class="hljs-string">-r</span> <span class="hljs-string">comment_node_id;</span> <span class="hljs-string">do</span>
            <span class="hljs-string">if</span> [ <span class="hljs-string">-n</span> <span class="hljs-string">"$comment_node_id"</span> ]<span class="hljs-string">;</span> <span class="hljs-string">then</span>
              <span class="hljs-string">echo</span> <span class="hljs-string">"Hiding review comment: $comment_node_id"</span>
              <span class="hljs-string">gh</span> <span class="hljs-string">api</span> <span class="hljs-string">graphql</span> <span class="hljs-string">-f</span> <span class="hljs-string">query='</span>
                <span class="hljs-string">mutation($id:</span> <span class="hljs-string">ID!)</span> {
                  <span class="hljs-string">minimizeComment(input:</span> {<span class="hljs-attr">subjectId:</span> <span class="hljs-string">$id</span>, <span class="hljs-attr">classifier:</span> <span class="hljs-string">OUTDATED</span>}<span class="hljs-string">)</span> {
                    <span class="hljs-string">minimizedComment</span> {
                      <span class="hljs-string">isMinimized</span>
                    }
                  }
                }<span class="hljs-string">' -f id="$comment_node_id"
            fi
          done

      - name: Run Claude Code Review
        id: claude-review
        uses: anthropics/claude-code-action@v1
        with:
          claude_code_oauth_token: $<span class="hljs-template-variable">{{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}</span>
          allowed_bots: '</span><span class="hljs-string">*'</span>
          <span class="hljs-attr">prompt:</span> <span class="hljs-string">|
            REPO: ${{ github.repository }}
            PR NUMBER: ${{ github.event.pull_request.number }}
</span>
            <span class="hljs-attr">Please review this pull request and provide feedback on:</span>
            <span class="hljs-bullet">-</span> <span class="hljs-string">Code</span> <span class="hljs-string">quality</span> <span class="hljs-string">and</span> <span class="hljs-string">best</span> <span class="hljs-string">practices</span>
            <span class="hljs-bullet">-</span> <span class="hljs-string">Potential</span> <span class="hljs-string">bugs</span> <span class="hljs-string">or</span> <span class="hljs-string">issues</span>
            <span class="hljs-bullet">-</span> <span class="hljs-string">Performance</span> <span class="hljs-string">considerations</span>
            <span class="hljs-bullet">-</span> <span class="hljs-string">Security</span> <span class="hljs-string">concerns</span>
            <span class="hljs-bullet">-</span> <span class="hljs-string">Test</span> <span class="hljs-string">coverage</span>

            <span class="hljs-string">Use</span> <span class="hljs-string">the</span> <span class="hljs-string">repository's</span> <span class="hljs-string">CLAUDE.md</span> <span class="hljs-string">for</span> <span class="hljs-string">guidance</span> <span class="hljs-string">on</span> <span class="hljs-string">style</span> <span class="hljs-string">and</span> <span class="hljs-string">conventions.</span> <span class="hljs-string">Be</span> <span class="hljs-string">constructive</span> <span class="hljs-string">and</span> <span class="hljs-string">helpful</span> <span class="hljs-string">in</span> <span class="hljs-string">your</span> <span class="hljs-string">feedback.</span>

            <span class="hljs-string">Use</span> <span class="hljs-string">`gh</span> <span class="hljs-string">pr</span> <span class="hljs-string">comment`</span> <span class="hljs-string">with</span> <span class="hljs-string">your</span> <span class="hljs-string">Bash</span> <span class="hljs-string">tool</span> <span class="hljs-string">to</span> <span class="hljs-string">leave</span> <span class="hljs-string">your</span> <span class="hljs-string">review</span> <span class="hljs-string">as</span> <span class="hljs-string">a</span> <span class="hljs-string">comment</span> <span class="hljs-string">on</span> <span class="hljs-string">the</span> <span class="hljs-string">PR.</span>

          <span class="hljs-comment"># See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md</span>
          <span class="hljs-comment"># or https://code.claude.com/docs/en/cli-reference for available options</span>
          <span class="hljs-attr">claude_args:</span> <span class="hljs-string">'--allowed-tools "Bash(gh issue view:*),Bash(gh search:*),Bash(gh issue list:*),Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*),Bash(gh pr list:*)"'</span>
</code></pre>
<p>Claude Code GitHub 리뷰 액션에는 버그가 하나 있다. 리뷰 코멘트를 <strong>너무 많이 남긴다</strong>.</p>
<p>이 때문에 PR이 리뷰 댓글로 도배되는 문제가 생긴다.</p>
<h2 id="heading-ai-1">AI 리뷰 활용법</h2>
<h3 id="heading-6riw67o4ioygkeq3va">기본 접근</h3>
<p>전제부터 분명히 하자.</p>
<ul>
<li><p>인간 리뷰는 느리다</p>
</li>
<li><p>인간 리뷰는 비싸다</p>
</li>
</ul>
<p>그래서 <strong>인간 리뷰를 최소화해야 한다</strong>.</p>
<p>이를 위해 선택한 전략은 다음과 같다.</p>
<ol>
<li><p>AI 리뷰 + CI를 먼저 통과시킨다</p>
</li>
<li><p>AI가 OK를 내릴 때까지는 인간이 개입하지 않는다</p>
</li>
<li><p>테스트와 자동 리뷰가 모두 통과된 경우에만</p>
</li>
<li><p>사람이 최종 리뷰를 한다</p>
</li>
</ol>
<p>즉,</p>
<blockquote>
<p>인간은 “최종 승인자” 역할만 맡는다</p>
</blockquote>
<ol>
<li><h3 id="heading-github">GitHub 앱 활용</h3>
</li>
</ol>
<p>AI 리뷰를 GitHub 앱 형태로 붙이면, PR 생성과 동시에 자동 리뷰가 시작된다.</p>
<p>이 단계에서는:</p>
<ul>
<li><p>코드 스타일</p>
</li>
<li><p>명백한 버그</p>
</li>
<li><p>구조적인 문제</p>
</li>
</ul>
<p>같은 것들을 AI가 먼저 걸러낸다.</p>
<ol start="2">
<li><h3 id="heading-github-actions-1">GitHub Actions를 사용해서 반영</h3>
<p> <img src="https://cdn.gamma.app/369hvd746fpmyb6/9151ee873c544e18a87b6143de64214c/original/image.png" alt /></p>
<p> 스크린샷과 같이 Claude Code GitHub Action등을 사용해서 반영해야 병렬 처리가 쉽다. 로컬에 체크아웃하는 것은 사람의 테스팅처럼 로컬에서 해야만 하는 상황에만 하는 것을 추천한다.</p>
</li>
<li><h3 id="heading-ci">CI 활용</h3>
</li>
</ol>
<p><img src="https://cdn.gamma.app/369hvd746fpmyb6/5afe35a1a3714b81976456d41f3bbdcb/original/seukeurinsyas-2026-01-30-ohu-5.33.30.png" alt /></p>
<p>중요한 건 CI를 단순한 테스트 도구가 아니라,</p>
<blockquote>
<p><strong>AI와 인간 사이의 방파제</strong></p>
</blockquote>
<p>로 사용하는 것이다. AI가 통과시키지 못한 변경사항은, 인간에게 도달하지 않게 만드는 것만으로도 리뷰 비용은 크게 줄어든다.</p>
<hr />
<h2 id="heading-qampa">Q&amp;A</h2>
<h3 id="heading-mcp">MCP가 필요없는 스펙인 이유</h3>
<p>특정 MCP 서버랑 똑같은 기능을 가진 CLI가 있다고 생각해보자. MCP를 통해서 수행할 수 있는 모든 건 CLI를 통해서도 수행할 수 있을 것이다. Vercel이 MCP를 만들지 않고 CLI 명령어를 개선한 것은 그래서이다.</p>
]]></content:encoded></item></channel></rss>