한국 기준으로, 학벌은 사람을 볼 때 꽤나 유용한 지표이지만, 절대적이지는 않다. 경험적인 얘기일 뿐이지만, 성균관대학교 자퇴생으로서 느낀 것들이 몇 가지 있다.

대학까지 간 사람의 학벌은 학습 능력 x 성실함 에 대체로 비례한다. 그래서 의미가 있는 것 같다. 나도 대학교 덕분에 사람들 큰 걱정 없이 편하게 만날 수 있었다. 근데 대체로가 함정인데, 내가 학교를 다니던 시절 기준으론 성대 정도의 학교도 쉽게 들어올 방법이 꽤나 있었고, 그런 경우 저 곱셈식이 어그러져서인지 대체로 문제가 살짝 있었다.

지금 생각해보면 성대의 특성일 수도 있다. 성대생들은 대체로 저 곱셈식에서 성실함의 비중이 꽤 되는 사람들이기 때문이다. 제대로 노력을 해 본 적 없는 사람들은 자기의 주제를 전혀 모르는데, 내 친구들 중엔 그런 사람이 거의 없었다.

지능의 유전

• 현재 인류 기준으로, 고지능자는 고지능 유전자가 많이 겹친 사람이다.

• 지능의 유전엔 X 염색체가 매우 중요한 역할을 한다. 그리고 이게 남자와 여자의 지능 분포 차이를 만든다. 극상위권에 여자가 거의 없는 이유가 이것이다.

  • 고지능 X 염색체가 여자한테서 발현되려면 2개가 있어야 한다. 이는 인간의 생물학적 특성인데, 여자는 X 성염색체가 2개이고 둘 중 하나는 세포군 단위 무작위로 비활성화된다. 이를 바소체 불활성화 또는 바소체 라이언화라고 부르는데, 발현 기댓값은 두 X 염색체의 평균이다.

  • 극상위권에 여자가 적은 것은 이 고지능 X 염색체가 매우 희귀하기 때문이다. 한 사람이 2개나 가지기가 쉽지 않다.

환경 vs 유전

• 같은 지능을 타고나도 훈련된 사람이 머리를 더 잘 쓴다. 간단한 예시로 수학 문제 푸는 것이 있다.

P.S.

개인적으로는 환경 vs 유전 자체가 어불성설이라고 본다. 지능이라는 것은 근본적으로, 진화라는 느린 과정 없이 런타임에 환경에 맞춰서 행동을 수정하겠다는 유전자의 전략이기 때문이다.

지능의 종류

• 지능은 단일 수치가 아니다.

메타인지

• 안다고 생각했는데 시험을 보려고 하니까 제대로 아는 것이 아니었다하는 경험이 적을수록 메타인지가 발달한 것이다. 메타인지가 정말 잘 되는 사람이라면 저런 일이 단 한 번도 없을 것이다.

• 자기가 메타인지가 잘 된다고 착각하는 사람이 많은데, 메타인지가 잘 발달한 사람이라면 공부에선 어지간하면 극상위다. (최상위 x). 극상위가 아니었다면 착각일 확률이 높다. 시험 보기 전에 자기가 뭘 모르는지 아는 사람들은 그것을 공부하면 되기 때문에 공부를 못하기가 쉽지 않다.

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 article, I’ll focus on topics that weren’t covered in that post.

Error Messages and Logging

Using Concrete Types and Schemas

The any type is dangerous even for humans—but it’s even more dangerous for AI.

The same applies to things like:

• Unconstrained parsing such as JSON.parse

• Loose interfaces

• Implicit or undocumented data structures

These patterns force AI to make too many assumptions.

The real problem is that once an assumption is wrong, all subsequent reasoning can spiral out of control.

So I try to follow these principles as much as possible:

• Use the most concrete types possible instead of any

• Prefer schema-based parsers over simple parsing
  (e.g., Zod or Yup instead of JSON.parse)

With this approach, even if the AI makes assumptions:

• The probability of those assumptions being wrong is lower

• When they are wrong, the system fails fast

In other words, this prevents AI from carrying incorrect reasoning all the way to the end.

Leveraging GitHub Actions

If you look closely, GitHub Actions has some surprisingly strong properties:

• Completely isolated environments

• Easy to configure

• A large collection of well-prepared examples

Instead of using it only for CI, I started treating it as a development virtual machine.

The same idea applies to AI.

“Whatever a developer can do locally,
AI should be able to do in exactly the same way.”

Setting Up a Development Environment for Claude Code

• Actual code: https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude.yml

name: Claude Code

on:
  issue_comment:
    types: [created]
  pull_request_review_comment:
    types: [created]
  issues:
    types: [opened, assigned]
  pull_request_review:
    types: [submitted]

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

      # Setup pnpm
      - name: Setup pnpm
        uses: pnpm/action-setup@v4.2.0

      - uses: actions/checkout@v4

      - name: Install Tauri dependencies
        run: |
            sudo apt-get update
            sudo apt-get install -y \
              libwebkit2gtk-4.1-dev \
              libappindicator3-dev \
              librsvg2-dev \
              patchelf

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable

      - name: Run Claude Code
        id: claude
        uses: anthropics/claude-code-action@v1
        with:
          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}

          # This is an optional setting that allows Claude to read CI results on PRs
          additional_permissions: |
            actions: read

          claude_args: |
            --allowed-tools Bash,WebFetch,WebSearch,Skill
            --model opus

With GitHub Actions, you can set things up so that:

• Package managers are installed

• Build commands are executed (pnpm build, cargo build, etc.)

• Tests are run

Once configured this way, Claude Code effectively operates in an environment that’s almost identical to a local development setup.

When the environment is this complete, the quality of AI output improves dramatically:

• It stops guessing

• It reasons based on actual execution results

• It produces “code that actually runs,” not just “code that should work in theory”

Managing Clean Commit Messages with AI

Preventing PR Description Spam

• Actual code: https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude-code-review.yml#L34-L55

name: Claude Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  claude-review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
      issues: read
      id-token: write

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 1

      - name: Dismiss old Claude bot comments
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          REPO="${{ github.repository }}"
          PR_NUMBER="${{ github.event.pull_request.number }}"

          gh api "repos/$REPO/issues/$PR_NUMBER/comments" --jq '.[] | select(.user.login == "claude[bot]") | .node_id' | while read -r comment_node_id; do
            if [ -n "$comment_node_id" ]; then
              gh api graphql -f query='
                mutation($id: ID!) {
                  minimizeComment(input: {subjectId: $id, classifier: OUTDATED}) {
                    minimizedComment {
                      isMinimized
                    }
                  }
                }' -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: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
          allowed_bots: '*'
          prompt: |
            REPO: ${{ github.repository }}
            PR NUMBER: ${{ github.event.pull_request.number }}

            Please review this pull request and provide feedback on:
            - Code quality and best practices
            - Potential bugs or issues
            - Performance considerations
            - Security concerns
            - Test coverage

            Use the repository's CLAUDE.md for guidance on style and conventions. Be constructive and helpful in your feedback.

            Use `gh pr comment` with your Bash tool to leave your review as a comment on the PR.

          claude_args: '--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:*)"'

There’s one bug in the Claude Code GitHub review action: it leaves too many review comments.

This can easily result in PRs being flooded with AI-generated comments.

How to Use AI Reviews Effectively

Core Assumptions

Let’s be explicit about the premises:

• Human reviews are slow

• Human reviews are expensive

Therefore, the goal is to minimize human involvement.

The strategy I chose is:

1. Run AI reviews and CI first

2. Humans do not intervene until AI gives an OK

3. Only when tests and automated reviews pass

4. A human performs the final review

In short:

Humans act only as the “final approver.”

1. Using a GitHub App

By integrating AI reviews as a GitHub App, reviews start automatically as soon as a PR is opened.

At this stage, AI filters out:

• Code style issues

• Obvious bugs

• Structural problems

2. Applying Changes via GitHub Actions

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.

3. Using CI as a Gatekeeper

The key is to treat CI not just as a testing tool, but as:

A barrier between AI and humans

If AI-generated changes can’t pass CI, they never reach human reviewers. That alone significantly reduces review costs.

Q&A

Why MCP Is Unnecessary for This Use Case

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.

AI 활용법 관련해서 간단하게 발표를 했다. 발표 자료 앞쪽은 전에 블로그에 올린 글이랑 같은 내용이다. 이 글에서는 기존 글에서 다루지 않은 내용들을 다루겠다.

에러 메시지 및 로깅

구체적 타입 및 스키마 활용

any 타입은 사람에게도 위험하지만, AI에게는 더 위험하다.

마찬가지로,

• JSON.parse처럼 아무 제약 없는 파싱

• 느슨한 인터페이스

• 암묵적인 데이터 구조

이런 것들은 AI가 너무 많은 가정을 하게 만든다.

문제는 그 가정이 틀리면, 이후의 모든 판단이 연쇄적으로 꼬인다는 점이다.

그래서 가능한 한 다음을 지향한다.

• any 타입 대신 최대한 구체적인 타입 사용

• 단순 파싱 대신 스키마 기반 파서 사용
  (예: JSON.parse 대신 Zod, Yup 같은 라이브러리)

이렇게 하면 AI가 가정을 하더라도,

• 그 가정이 틀릴 확률이 줄어들고

• 틀렸을 경우 즉시 실패하도록 만들 수 있다

즉, AI가 잘못된 추론을 끝까지 끌고 가는 상황을 예방할 수 있다.

GitHub Actions 활용

GitHub Actions를 잘 보면 꽤 괜찮은 특징을 갖고 있다.

• 완전히 격리된 환경

• 구성하기 쉬움

• 이미 잘 구성된 예제가 많음

이걸 단순히 CI 용도로만 쓰지 않고,
개발용 가상 머신처럼 사용하는 접근을 했다.

AI에게도 마찬가지다.

“로컬에서 개발자가 할 수 있는 걸
AI도 똑같이 할 수 있게 만들어준다”

라는 관점이다.

Claude Code를 위한 개발 환경 구성

• 실제 코드: https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude.yml

name: Claude Code

on:
  issue_comment:
    types: [created]
  pull_request_review_comment:
    types: [created]
  issues:
    types: [opened, assigned]
  pull_request_review:
    types: [submitted]

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

      # Setup pnpm 
      - name: Setup pnpm
        uses: pnpm/action-setup@v4.2.0

      - uses: actions/checkout@v4

      - name: Install Tauri dependencies
        run: |
            sudo apt-get update
            sudo apt-get install -y \
              libwebkit2gtk-4.1-dev \
              libappindicator3-dev \
              librsvg2-dev \
              patchelf

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable

      - name: Run Claude Code
        id: claude
        uses: anthropics/claude-code-action@v1
        with:
          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}

          # This is an optional setting that allows Claude to read CI results on PRs
          additional_permissions: |
            actions: read

          claude_args: |
            --allowed-tools Bash,WebFetch,WebSearch,Skill
            --model opus

GitHub Actions에서:

• 패키지 매니저 설치

• 빌드 명령 실행 (pnpm build, cargo build 등)

• 테스트 실행

까지 모두 가능하게 구성해두면,
Claude Code는 사실상 로컬 개발 환경과 거의 동일한 조건에서 동작한다.

이렇게 환경이 갖춰져 있으면 AI의 작업 품질이 눈에 띄게 좋아진다.

• 추측으로 답하지 않고

• 실제 실행 결과를 기반으로 판단하고

• “이론상 맞는 코드” 대신 “실제로 도는 코드”를 만든다

AI로 커밋 메시지 예쁘게 관리하기

PR 본문 스팸 방지

• 실제 코드: https://github.com/delinoio/delidev/blob/abed0d02fd30524bfb2f77f7227bf9560092e949/.github/workflows/claude-code-review.yml#L34-L55

name: Claude Code Review

on:
  pull_request:
    types: [opened, synchronize]
    # Optional: Only run on specific file changes
    # paths:
    #   - "src/**/*.ts"
    #   - "src/**/*.tsx"
    #   - "src/**/*.js"
    #   - "src/**/*.jsx"

jobs:
  claude-review:
    # Optional: Filter by PR author
    # if: |
    #   github.event.pull_request.user.login == 'external-contributor' ||
    #   github.event.pull_request.user.login == 'new-developer' ||
    #   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'

    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
      issues: read
      id-token: write

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 1

      - name: Dismiss old Claude bot comments
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          # Get PR comments from claude[bot] and hide them as outdated
          REPO="${{ github.repository }}"
          PR_NUMBER="${{ github.event.pull_request.number }}"

          # Get issue comments (gh pr comment creates issue comments, not review comments)
          gh api "repos/$REPO/issues/$PR_NUMBER/comments" --jq '.[] | select(.user.login == "claude[bot]") | .node_id' | while read -r comment_node_id; do
            if [ -n "$comment_node_id" ]; then
              echo "Hiding review comment: $comment_node_id"
              gh api graphql -f query='
                mutation($id: ID!) {
                  minimizeComment(input: {subjectId: $id, classifier: OUTDATED}) {
                    minimizedComment {
                      isMinimized
                    }
                  }
                }' -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: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
          allowed_bots: '*'
          prompt: |
            REPO: ${{ github.repository }}
            PR NUMBER: ${{ github.event.pull_request.number }}

            Please review this pull request and provide feedback on:
            - Code quality and best practices
            - Potential bugs or issues
            - Performance considerations
            - Security concerns
            - Test coverage

            Use the repository's CLAUDE.md for guidance on style and conventions. Be constructive and helpful in your feedback.

            Use `gh pr comment` with your Bash tool to leave your review as a comment on the PR.

          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
          # or https://code.claude.com/docs/en/cli-reference for available options
          claude_args: '--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:*)"'

Claude Code GitHub 리뷰 액션에는 버그가 하나 있다. 리뷰 코멘트를 너무 많이 남긴다.

이 때문에 PR이 리뷰 댓글로 도배되는 문제가 생긴다.

AI 리뷰 활용법

기본 접근

전제부터 분명히 하자.

• 인간 리뷰는 느리다

• 인간 리뷰는 비싸다

그래서 인간 리뷰를 최소화해야 한다.

이를 위해 선택한 전략은 다음과 같다.

1. AI 리뷰 + CI를 먼저 통과시킨다

2. AI가 OK를 내릴 때까지는 인간이 개입하지 않는다

3. 테스트와 자동 리뷰가 모두 통과된 경우에만

4. 사람이 최종 리뷰를 한다

즉,

인간은 “최종 승인자” 역할만 맡는다

1. GitHub 앱 활용

AI 리뷰를 GitHub 앱 형태로 붙이면, PR 생성과 동시에 자동 리뷰가 시작된다.

이 단계에서는:

• 코드 스타일

• 명백한 버그

• 구조적인 문제

같은 것들을 AI가 먼저 걸러낸다.

2. GitHub Actions를 사용해서 반영

   

   스크린샷과 같이 Claude Code GitHub Action등을 사용해서 반영해야 병렬 처리가 쉽다. 로컬에 체크아웃하는 것은 사람의 테스팅처럼 로컬에서 해야만 하는 상황에만 하는 것을 추천한다.

3. CI 활용

중요한 건 CI를 단순한 테스트 도구가 아니라,

AI와 인간 사이의 방파제

로 사용하는 것이다. AI가 통과시키지 못한 변경사항은, 인간에게 도달하지 않게 만드는 것만으로도 리뷰 비용은 크게 줄어든다.

Q&A

MCP가 필요없는 스펙인 이유

특정 MCP 서버랑 똑같은 기능을 가진 CLI가 있다고 생각해보자. MCP를 통해서 수행할 수 있는 모든 건 CLI를 통해서도 수행할 수 있을 것이다. Vercel이 MCP를 만들지 않고 CLI 명령어를 개선한 것은 그래서이다.

Intuitive API is a must.

Everything should work intuitively, based on the name. AI tends to avoid digging into the lower layer unless you explicitly instruct it to fix it. For example, if enabled: false does not work in the code below, AI will fail to fix it most of the time because it assumes that the option works as expected.

Subagents may reduce context window usage.

Use subagents proactively.

You can utilize subagents to reduce the usage of the main context window. The only thing you need to do is saying Use subagents proactively in the prompt. It’s useful when you need to do a very large task. It makes Claude Code less intelligent for tasks that require the organic analysis of multiple clues, though.

Note: I didn’t define any subagents in my repository. General subagents are enough for this trick.

The API reference document reduces the guess-and-grep loop.

If you don’t specify the name of the method you want to fix, the AI agent will guess the method/variable/module name and grep for it repeatedly until it finds the relevant code.

This means that if you can provide an API reference document listing all method names, the coding agent will be much more efficient. As a side note, the best thing is an RPC API specification file that lists all method names and only the RPC message name.

syntax = "proto3";
package delino.appcore.v1;
option go_package = "github.com/delinoio/cloud/rpc/appcore";

import "appcore/auth.proto";

service AppCore {
  rpc UpdateUserProfile(UpdateUserProfileRequest) returns (UpdateUserProfileResponse);
}

Mentioning this file would give the AI agent

• the name of RPC methods to grep for

• the names of RPC message types to grep for

so the AI agent will never need to repeatedly guess the names.

Provide the design document, and ask the AI agent to update it.

The source of truth was the code. And yeah, the primary source of truth is still code. But you can’t feed the whole code into AI agents, and updating code requires lots of tokens. I’m not talking about the token cost. It’s about the context window size. That’s why we need a specification document that is up-to-date with the codebase and committed to the repository.

Luckily, having one is easy. You don’t need to update it manually. Instead, instruct the AI agent to read the design document before any task, and update it as required.

You may start building in a separate session after creating a plan.

• Applies to: Claude Code.

The plan mode is great. It’s a really wonderful feature that allows you to create a comprehensive task input prompt that mentions all the relevant files. But sometimes, Claude Code runs compaction nearly immediately after approving the plan because it does not clear the context before executing the plan. If you want, you can instruct it to write the comprehensive task prompt as a Markdown file, and /clear the context window, and paste it there.

In this way, Claude Code will run with a fresh context window, reading referenced files as required. It’s useful if you've done a lot of ping-pong with the planning agent.

Provide project structure.

You can provide the project structure using the instruction file (CLAUDE.md/AGENTS.md) or a custom command. Giving the project structure also reduces the number of tokens wasted to guess the project structure.

Personally, I prefer a monorepo, so I have commands like /work-on-devbird that mentions the relevant frontend/backend directory, the RPC definition, and the design documents.

Mention the filepath or the names of utility functions.

This is a good fit for the instruction files, like CLAUDE.md and AGENTS.md. The AI agent has limited knowledge of the project, so it may repeat the same code over and over. It isn’t good. If you instruct it to read the utility file beforehand, it will reuse the existing function.

If you don’t understand something, throw the whole text to the Plan Mode.

You don’t need to understand everything, seriously. You don’t need to give it a perfect prompt. Instead, you can use plan mode to expand your thoughts within the project context. Sometimes I didn’t understand some requirements because they are specific to the project, but Claude Code's plan mode expanded them into a concrete plan prompt. You can even ask Claude Code to ask you back. You can do clarification based on the questions the Claude Code asks.

2025년은 나한테 롤러코스터 같은 한 해였다. 많은 일들이 있었고 환경의 변화도 많았다. 미국과 한국을 오갔고, 소속된 곳이 바뀌었으며, 새로운 사람들을 만났다. 지난 1년을 타임라인을 따라 정리해 본다.

커리어 변화

4월 16일: Vercel 본사 근무를 위한 Relocation

Vercel 본사 근무를 위해 미국으로 이동했다. 짧지 않은 기간 동안 현지에서 일하며, 이전과는 다른 환경과 문화 속에서 일을 하게 됐다.

6월 16일: 귀국

두 달 정도의 미국 생활을 마치고 한국으로 돌아왔다. 이 시점까지도 이후의 방향이 명확하게 정해져 있던 것은 아니었다.

7월: Vercel 퇴사

어쩌다 보니 Vercel을 퇴사하게 됐다. 당시에는 회사가 지나치게 무례하다고 느꼈고, 더 이상 같이 일하고 싶지 않다는 감정이 컸다. 분노와 피로가 동시에 있었다. 말해봤자 무슨 소용이 있을까 싶을 정도였다.

시간이 조금 지난 뒤, 미국 기업 문화에 대해 미국에 거주하는 분들의 이야기를 듣고, 또 인공지능을 통해 정리해보면서 그 상황을 다시 바라보게 됐다. 미국 정서 기준으로 보면 회사 쪽이 특별히 잘못했다고 보기는 어려웠다. 한국 기준으로는 쉽게 받아들이기 힘든 방식이었지만, 억울함을 말하고 싶은 건 아니다. 그 당시의 나는 그렇게 느꼈고, 그게 전부였다.

7월: Delino 창업

나는 원래 창업이 하고 싶었다. 아이템도 여러 개 생각해두고 있었다. 마침 퇴사를 하게 되었고, 결과적으로는 잘 된 선택이었다고 생각한다. 감정과는 별개로, 방향을 바꾸기에 적절한 시점이었다.

8월 9일: Real Prompter 런칭

Claude Code를 활용해 여러 서비스를 만들면서 한 가지를 계속 느꼈다. LLM을 제대로 활용하는 것은 생각보다 어렵다는 점이었다. 많은 사람들이 “프롬프팅은 어떻게 하느냐”고 물어봤고, 나는 반복해서 비슷한 답을 해왔다.

Roo Cline 등을 사용해 내가 실제로 하던 작업 방식들을 블로그와 SNS를 통해 여러 번 공유했고, 이를 반복하다 보니 서비스화하는 편이 낫겠다는 생각이 들었다. 그렇게 Real Prompter를 만들게 됐다.

10월 14일: AutoDev 런칭

LLM을 잘 사용하는 것이 요령이나 감각의 문제인 것은 맞지만, 시스템적인 방식으로 근본적으로 해결할 수 있는 문제라고 생각했다. AI 덕분에 그 요령이나 감각조차 자동화가 가능한 시대라는 것이다.

AutoDev는 내가 이전부터 계속 이야기해오던 작업 방식을 자동화한 도구였다. 내가 강조해온 핵심은 몇 개 더 있지만, 가장 핵심적인 것은 세 가지였다.

1. 복잡한 작업을 적절한 단위로 쪼개는 것

2. 여러 세션에 걸쳐 반복적으로 검증하고 피드백을 받는 구조

3. CI와 자동 테스트를 활용한 회귀(regression) 방지

이건 새로운 아이디어라기보다는, 내가 계속 해오던 방식이었다. AutoDev는 그 방식을 도구로 옮긴 결과였다.

10월 15일: 인프런 멘토링

돈을 받고 진행한 내 인생 첫번째 멘토링이라서 적기로 했다. 인프런을 통해서 진행한 것이었고, AI 활용법 및 오픈소스 관련 전략에 대해서 많은 얘기를 나누었다. 가격이 한국 기준으론 상당한 가격이었기에 감사한 마음으로 사전 질문들 및 추후 추가 질문들도 답변해드렸다.

10월 23일: AutoDev → DevBird 리브랜딩

Microsoft에서 만든 AutoDev와 이름이 겹치면서 SEO가 사실상 불가능했다. 결국 DevBird로 리브랜딩했다. 제품의 방향이나 철학이 바뀐 것은 아니었다.

10월 27일: Zack과 미팅

Zephyr Cloud의 CEO인 Zack과 미팅을 가졌다. 네트워킹으로 분류할 수도 있었지만, 이후의 커리어와 연결되는 지점이 있어서 이 글에서는 커리어 이벤트로 남긴다.

11월 1일: Zephyr Cloud 업무 시작

많은 여행

이번 해엔 나답지 않게 여행을 많이 다녔다.

4월 16일 ~ 6월 16일: 미국 Vercel 근무

미국에서 Vercel과 함께 일한 이 두 달은 즐거움과 떨림이 공존했던 시간이었다.
낯선 환경에서 일한다는 점에서 긴장도 됐지만, 좋은 친구들을 만나 덕분에 생각보다 빠르게 적응할 수 있었다. 새로운 사람들과 함께 일하며 많이 배웠다.

10월 초: 속초 가족 여행

힐링의 시간이었다. 맛있는 음식을 함께 먹는 시간이 특히 좋았지만, 집에 두고 온 고양이가 계속 마음에 걸려서 조금 일찍 돌아와야 했던 점은 아쉬움으로 남았다.

10월 중순: 부산 여행

동생이랑 부산 여행을 갔다왔다. 열심히 걸었지만 맛있는 음식을 너무 많이 먹었는지 갔다와서 재보니까 체중이 조금 늘었다. 그리고 갈 때 ITX를 탔다. 깨끗하긴한데 너무 느렸다. 그래서 올 때는 KTX 탔다.

해동 용궁사 같은 곳도 보고 왔고, 이재모 피자 같은 맛집도 많이 찾아다녔다.

11월 16일 ~ 23일: 미국 출장 (for Zephyr Cloud)

너무 재밌었다. 일주일간 한 customer onsite였는데 업무 시간엔 일을 엄청나게 많이 했고, 어쩌다보니 앞에 나가서 데모 발표도 했다. 그리고 업무 외 시간에는 대표분이 렌트하신 차로 같이 놀러다녔는데 이게 정말 재밌었다. 재밌는 여행을 할 수 있게 해주신 대표분께 감사드린다.

11월 말 ~ 12월 초: 일본 도쿄 여행

동생이랑 일본 도쿄로 짧은 여행을 갔다왔다. 도쿄 디즈니랜드 가서 재밌게 놀았고, 미녀와 야수라는 가장 인기 많은 놀이기구에 충격을 받았다. 그래도 디즈니랜드에서 다른 건 다 재밌었어서 만족스러웠다.

근데 숙소 위치를 조금 잘못 잡았던 것 같다. 신주쿠 가부키초 쪽이었는데 저녁엔 무서워서 안 나갔다.

12월 중순: 속초 가족 여행

홈캠 등의 장비들을 설치하고 가서 고양이 걱정을 덜 한 재밌는 여행이었다. 좋은 숙소에 묵고 맛있는 음식을 많이 먹은 여행이었는데, 숙소에서 일도 꽤 많이 했다.

많은 네트워킹과 발표

여러 자리에서 사람들을 만나며 느낀 건, 생각보다 많은 사람들이 비슷한 고민을 하고 있다는 점이었다.
“AI를 어떻게 잘 써야 할까?”라는 질문이 반복해서 나왔고, 나는 여전히 AI가 버블이라고 생각하지 않는다. 다만 AI를 제대로 쓰기 위해서는, 마법 같은 도구를 기대하기보다 구조와 시스템이 먼저 필요하다고 느꼈다.

1월 말: Vercel 최지원과 페어코딩

Vercel의 최지원님과 진행한 페어코딩은 협업 자체가 굉장히 재미있었던 경험이었다.
미국 회사에서 일하면서 한국인 동료와 함께 코드를 짜는 시간이어서 더 편안하고 즐겁게 느껴졌다.

3월 1일: 팀 스파르타(항해) 손윤주 씨와 커피챗

손윤주 씨와의 커피챗에서는 그분이 정말 성실하게 일하는 분이라는 인상을 받았다.
대화 중에는 내가 AI 이야기를 많이 했고, 노트북까지 꺼내 직접 데모를 보여주며 이야기를 이어갔다.

3월 11일: 항해 AI 웨비나

이 웨비나는 개인적으로 정말 즐거운 경험이었다.
평소 주변 사람들에게 “AI는 이제 무조건 써야 한다”고 이야기하고 다녔는데, 그 메시지를 웨비나라는 공식적인 자리에서 정리해 전달할 수 있어서 좋았다. AI 도구들을 소개하며 내가 계속 강조해오던 이야기를 꺼낼 수 있었던 시간이 오래 기억에 남는다.

3월 27일: 성균관대학교 강연

원래는 긴장을 안 할 거라고 생각했지만, 교수님들이 지켜보고 계셔서 생각보다 긴장이 됐다.
그럼에도 불구하고 교수님들이 흥미롭게 들어주시고 질문까지 해주셔서 강연을 마치고 나서는 꽤 뿌듯한 기분이 들었다.

8월 6일: 오픈소스 밋업

오픈소스 밋업에서는 다양한 이야기를 들을 수 있었지만, 한편으로는 아쉬운 지점도 있었다.
오픈소스 기여를 마치 개인의 성과나 이력서 한 줄처럼 이야기하는 분위기가 있었는데, 오픈소스는 결국 문제를 함께 해결하기 위해 모이는 공동체라는 점을 다시 생각하게 됐다.

9월 16일: 크래프톤 정글 팟캐스트

이 자리에서는 Vercel에서의 경험과 실리콘밸리에서의 일하는 방식, 그리고 AI 시대에 개발자가 어떤 자세를 가져야 하는지에 대해 많이 이야기했다.
전하고 싶은 메시지가 많다 보니 조금 정리가 덜 된 채로 이야기를 한 점은 아쉬움으로 남았다.

9월 18일: Marco Ippolito 님의 서울 방문

• https://x.com/satanacchio/status/1968670634885500997

Marco Ippolito 님과의 만남은 서로의 경험을 나누며 굉장히 유익한 시간이었다.
Node 컨트리뷰터분이신데 인사이트가 매우 깊었고, 개인적으로도 많은 것을 배울 수 있었다.

9월 30일: HOCO 팟캐스트

크래프톤 정글 팟캐스트와 비슷한 주제를 다뤘지만, 이번에는 미리 블로그 글로 생각을 정리해 둔 상태에서 이야기를 풀어갈 수 있었다.
덕분에 훨씬 정돈된 흐름으로 설명할 수 있었고, 스스로도 잘했다고 느낀 자리였다.

10월 24일: 토스 프다클

토스 프다클에서는 사람들이 AI를 사용하는 수준이 생각보다 크게 다르다는 걸 실감했다.
그 경험을 통해 내가 앞으로 무엇을 해야 할지, 또 어떤 방식으로 사람들을 도울 수 있을지 감을 잡게 됐다. 동시에 개인적으로도 많은 인사이트를 얻은 의미 있는 시간이었다.

10월 30일: 항해 AI 웨비나 2

기타 이벤트

2월 중순: 수면 문제 해결

내가 원래 잠을 되게 못 자는 사람이었다. 어느 날 우연히 상추차를 접하게 되었는데, 상추차를 마시니까 잠이 잘 왔다. 며칠 실험해보고 이건 진짜라는 것을 깨달았다. 그리고 지금은 상추환으로 정착했다. 상추차를 농축해서 환으로 만들어놓은 것인데, 상추차는 차의 특성상 우리거나 마시는 데에 시간이 걸리고, 물을 많이 마시다보니 아침에 자꾸 깨서 상추환이 훨씬 나았다. 상추환을 꾸준히 먹다보니 수면에 관련된 호르몬 자체가 선순환으로 들어간건지 이제는 낮 시간에도 졸리면 낮잠을 잘 수 있게 됐다. 삶의 질이 아주 높아져서 행복하다.

11월 초: 사촌동생 결혼식

사촌동생 결혼식에 참석했다. 놀랍게도 이게 내가 가 본 첫번째 결혼식이다. 나보다 어린 나이에, 오랜 시간 함께한 연인과 결혼하는 모습을 보니까 부러웠고, 나도 원래 한명하고 오래 연애하다가 27살 쯤에 결혼하고 싶었던 사람이라서 여러 가지 생각이 들었다. 이 이벤트가 나한테 꽤나 큰 변화를 남겨서 회고록에 적는다.

마치며

2025년을 지나온 지금, 예전보다 자유롭고 행복하다. 내 일을 충분히 잘 해내고 있는 것 같아서 뿌듯하기도 하다. 여전히 실험 중이고, 여전히 복잡한 문제를 풀고 있지만, 지금의 상태는 나쁘지 않다고 느낀다.

오늘 발표에서 얘기할 내용들입니다.

기본 태도

• 적극적으로 사용해야 함. 모든 도구를 사용해볼 필요는 없지만, 좋은 평을 받는 도구는 시도해볼 것.

• AI를 적극적으로 활용하는 기업 기준, 현 시점에서 이미 프론트엔드/백엔드 같은 것은 안 중요함.

• 모든 것을 다 알아야한다는 태도는 반드시 버릴 것. 이것은 개발 씬에서 원래도 문제임. 솔직하게 말하면 개발 소질 이슈. 애매한 중상위권의 특징임.

  • 원리 이해 같은 경우, 난이도가 훨씬 낮지만 효율적인 방법은 아님.

    • 자기가 국소적 이해 기반의 코딩을 할 수 없다면 전체 설계를 이해해서라도 코딩을 해야함.

  • 큰 프로젝트 여러 개를 동시에 해야하는 경우 국소적 이해로 코딩하는 능력이 필수임.

    • 이 능력을 습득하고 싶으면 규모가 꽤 있지만 본인은 잘 모르는 오픈소스에 기여하는 것이 최고라고 생각.

    • 오픈소스에서 이것이 특히 중요한데, 규모가 큰 프로젝트 여러 개에 각각 패치를 보내야하는 일이 생각보다 자주 있는데 물어볼 사람도 없고, 문서도 내부 구현에 대한 것은 없는 경우가 대부분인데 각 프로젝트를 제대로 이해하고 작업하려고 하면 작업 시간이 지나치게 늘어남.

바이브코딩의 문제 해결책

• 바이브 코딩의 단점을 막을 가장 중요한 해결책은 테스트

• 스펙 문서는 항상 넘겨주고 적절한 수정을 요청할 것.

• 바이브 코딩 이후 작업에 대한 설명이 명확하게 이해가 안 간다면 관련 개념을 공부하는 것을 추천. 그 뒤에도 이해가 안 가면 컴퓨팅적 사고력의 문제.

AI 시대의 능력

• 1인 창업이 맞는 시대라고 보지만 (당연히) 자기 능력 검증은 필수.

• AI 없이 처음부터 끝까지 개발하기 위한 능력은 필요치 않음.

• 다시 말해, 코딩하는 능력 자체는 이제 의미가 없음.

• 하지만 AI 를 활용해서 학습하고 코딩하는 능력은 매우 중요함.

  • 바이브 코딩 이후 AI의 설명이 이해가 안 간다면 복사해서 다른 인공지능 챗봇에 붙여넣은 뒤 어떤 개념을 공부해야 이 설명을 이해할 수 있는지 물어보고 공부할 것.

이 시대의 문제 해결 능력은 2가지

• 새로운 문제를 만들지 않는 것

  • 핵심은 테스트의 활용

• 주어진 문제를 고치는 것

  • AI를 활용해보고, 문제가 생겼을 때 AI를 활용해서 해결한 경험이 많은 것이 중요함.

  • 어떻게 하면 해결되는지는 본인이 전부 기억하고 있어야 함.

지능 vs 지식

• 원래 시대가 빠르게 바뀔수록 순수 지능이 중요함. 근데 지능이란 건 함수 같은 것이고 쓰던 사람이 잘 씀. 공부할 때도 머리를 많이 쓰는 방식을 사용하는 것이 좋음.

  • 바이브 코딩하는 방법을 책이나 강의로 배울 생각을 한다면 바이브코딩 관련 재능 중 제일 중요한 것이 없는 것. 공부 방법을 근본적으로 바꿔야 함.

  • 강의나 책은 자기의 사고력을 덜 쓰는 방법이라서 편하지만 이 시대에 최악인 습관임.

• CS 지식 자체는 중요하지 않음. 중요한 건 컴퓨팅적 사고. 이게 처음부터 자유자재로 되는 사람이 있는데 그런 사람은 AI 적극적으로 쓴다는 전제 하에 CS 지식 따로 안 배워도 됨. 근데 이 애기는 천재에 대한 얘기가 아니고 생각보다 이것이 처음부터 되는 사람이 많음. 코테는 컴퓨팅적 사고가 안 되는 사람을 거르는 역할을 함.

• 코딩하는 능력 자체도 마찬가지로 코딩하는 능력이 없어도 거의 모든 개발이 가능함. 그래서 프로덕트 엔지니어라는 직군으로 바뀌는 것.

• 메타인지가 오히려 더 중요. 자기가 메타인지가 있는지 확인하는 방법:

  • 안다고 생각했는데 시험 때 생각 안 났다라는 경험이 한번이라도 있으면 메타인지가 없다고 치고 공부 계획을 짜야함.

  • 자기가 모르는데 안다고 착각하면 해결책 없는 교착 상태가 생김. 안다고 전제하지 말 것.

기타 정보

• 실리콘밸리의 새로운 변화는 보통 1~2달 정도의 시차를 두고 한국에 들어옴.

  • 프로덕트 엔지니어 직군 / AI 네이티브 인재 채용 (카카오) 등

• 코테는 허수 (컴퓨팅적 사고 안 되는 사람들) 거르기 + 면접에 드는 품 줄이기.

• 사람 급 나누기에 미친 사람들

• 중범죄자

  • 음주운전 등.

• 자기의 조그만 이익을 위해 남들한테 큰 피해를 주는 걸 아무렇지 않게 생각하는 사람들.

  • 예를 들어 우회전 할 때 반드시 지나가야하는 위치에 차 세워놓는 사람들.

• 자기 잘못은 어떻게든 합리화하는 사람들.

• 남들한테 피해주면서까지 돈 벌려는 사람들.

• 각종 망상이 심각한 사람들.

• 나 이용하려는 게 너무 티나는 사람들.

• 자기 잘못을 이해하는 능력이 글러먹은 사람들.

• 윤리의식이 나랑 너무 안 맞는 사람들.

• 쓰레기 짓 해놓고 지가 머리 잘 썼다고 생각하는 사람들.

• 자신의 이익을 위해 상황을 변조하는 사람들.

  • 일부 사실만 공개하는 것은 제외.

• 남의 돈으로 생색내는 사람들.

이렇게 늘어놓으면 인생 피곤하게 사는 것처럼 들릴 수도 있는데 이 사람들한테 공통점이 있어서 피하는 것이 그리 어렵지는 않은 것 같다.

I configured Claude Code GitHub Action correctly. You should add setup steps to emulate a real development environment before anthropics/claude-code-action@beta. The setup steps depend on the repository, but I’ll provide my Claude Code Action Setup as a reference.

.github/workflows/claude.yml:

name: Claude Code

on:
  issue_comment:
    types: [created]
  pull_request_review_comment:
    types: [created]
  issues:
    types: [opened, assigned]
  pull_request_review:
    types: [submitted]

jobs:
  claude:
    if: |
      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
    runs-on: ['self-hosted', 'linux']
    permissions:
      contents: read
      pull-requests: read
      issues: read
      id-token: write
      actions: read # Required for Claude to read CI results on PRs
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 1

      - name: Install Protoc
        uses: arduino/setup-protoc@v3
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}

      - name: Setup Node.js
        uses: ./.github/actions/setup-node

      - name: Configure environment
        run: pnpm install

      - name: Run Claude Code
        id: claude
        uses: anthropics/claude-code-action@beta
        with:
          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}

          # This is an optional setting that allows Claude to read CI results on PRs
          additional_permissions: |
            actions: read

          # Optional: Specify model (defaults to Claude Sonnet 4, uncomment for Claude Opus 4)
          # model: "claude-opus-4-20250514"

          # Optional: Customize the trigger phrase (default: @claude)
          # trigger_phrase: "/claude"

          # Optional: Trigger when specific user is assigned to an issue
          assignee_trigger: "claude-bot"

          # Optional: Allow Claude to run specific commands
          allowed_tools: "Bash,WebFetch,WebSearch"

          # Optional: Add custom instructions for Claude to customize its behavior for your project
          # custom_instructions: |
          #   Follow our coding standards
          #   Ensure all new code has tests
          #   Use TypeScript for new files

          # Optional: Custom environment variables for Claude
          # claude_env: |
          #   NODE_ENV: test

Note allowed_tools: "Bash,WebFetch,WebSearch". You need it to allow Claude Code to run bash commands.

Usage

Mention @claude from issues or PRs to instruct it to resolve issues.

Example:

@claude Implement comprehensive unit tests

Pro Tip: You can use local Claude Code to create a handful of issues quickly

However, there is another method, and this one is the most convenient and free. It involves using a virtual private network (VPN) service called Tailscale. After logging in and registering your device, each device is assigned an IP address.

After running the server on your development laptop, you can check the IP address of the device in the Tailscale app and connect to it using that IP address, as shown in the screenshot, to access the development server.

This is also the best option when creating a service that only you can access, as you don't need to set up complex external access settings. Install Tailscale on the specific device, deploy the service, and connect. Installing Tailscale on the server can also be done with a single line of script, making it very convenient.

As you can see on the left side of the screenshot, chats can be organized like folders, and there are features such as setting different system prompts for each folder. For example, you can set it to only use official documents for matters related to law or taxation.

With LLM models, connecting OpenRouter allows you to utilize a huge number of models freely. The models shown in the screenshot are ones that I have selected and activated. Since my family also uses it, I thought it might be unclear if there were too many.

When you turn on the web search function in the chat feature, it searches for information and organizes it for you. When the image feature is enabled, it generates images. When numbers appear during the inference process or there is a lot to manage, it uses LLM to code, executes it, and then uses the results to provide answers.

Since it supports PWA, you can add it to the home screen on mobile devices or use the app installation feature in desktop Chrome to use it like a native app.

The number of concurrent GitHub Action runners is determined by the plan of the GitHub Org to which the repository belongs, regardless of whether the repository is public. Even though GitHub Actions are unlimited and free for public repositories, they are still affected. Because of this, SWC uses the Enterprise plan.

If you're running a large open-source project and are having issues with GitHub Actions only running 20 jobs at a time, you can upgrade your plan to Team or Enterprise.

• Documentation link: https://docs.github.com/en/actions/reference/limits#job-concurrency-limits-for-github-hosted-runners

Service XXX is for ...

If anything is ambiguous or you are not sure about it, do not infer but ask me.

After spending a handful of times for clarifying everything and describing entity relations, I ask it to store it as a markdown file. Typically, it generates a very, very long text. I then follow getting started step of the framework I want to use. The latest one I used is tauri. I do this step manually just because typically it's just a few CLI commands. After creating a directory, I ask Claude Code to

Implement app in @apps/xxx.

[Paste the design markdown file content]

You'll get a bare minimum prototype that works with dummy data. Even after getting the initial version, I ask Claude Code for all modifications.

tl;dr:

I forked rayon to allow switching parallelization library or disable parallelization. See par-iter and par-core.

I'm the creator of the SWC project. I've been using chili the SWC Minifier. chili is a parallelization library with a heartbeat scheduling algorithm. I found that it performs far better than rayon for my usecase. But it lacks an API like parallel iterators of rayon. Additionally, I need to use different parallelization libraries for next.js or rspack and disable parallelism for Wasm targets. So I forked rayon and named it par-iter. par-iter is based on par-core, which allows selecting rayon or chili for parallelism or even disabling parallelism using cargo features.

I prefer to get it merged back to rayon , so I filed an issue on the rayon issue tracker to ask if they are open to PR for it, but I don't think it's likely, considering the package name.

Any ideas, thoughts, and feedback are welcome!

발표 자료 만들다가 이 내용을 블로그에 적지 않았다는 것을 깨달아서 늦게나마 올린다.

This is the screenshot of a base image setup process. I installed nodejs and did pnpm install. So there’s a folder named node_modules. After then, I clicked Finish Setup button, an pressing the button creates a base docker image for the worker. It utilizes the docker commit command.

• Screenshot captured from a running instance of pnpm dev (using turborepo)

And after waiting for a while, I could use the base image in a worker. The base image does not have the AutoPilot vscode extension nor Roo Code, but the worker image has one.

This is the screenshot of a new worker instance, from which you can find node_modules, Roo Code, and Dudy AutoPilot vscode extension.

With this change, a worker can drive a task from the start to the end by itself without an interaction. But I still need to polish lots of things, and I would be busy this weekend because of a GDG event.

• Side note: I’ll not sell this as SaaS, to avoid competing with v0

Yesterday, I managed to automatically spawn a code-server instance with my Dudy AutoPilot extension and Roo Code extension installed. Once the user approves the plan for a task, a vscode worker is spawned to resolve the task.

Today, I made it automatically clone the repository, configure Roo Code using secrets sent by the server, and start a new task with Roo Code.

tl;dr;

제 .cursorrules 파일은 다음과 같습니다.

 - First, look for glob `**/.AI.md`. Use terminal command `find . -name '.AI.md'` from the project root, if required.
 - Second, if you are going to read and/or write any file in a directory containing `.AI.md` files from the first step, read all of them and respect the instructions in them.
 - For example, if you are reading or writing a file at /a/b/c, you should check for `/a/.AI.md`, `/a/b/.AI.md` and `/a/b/c/.AI.md` in the order.

감이 오시나요? 이런 방식으로 AI한테 어떤 폴더에서는 어떻게 작업해야하는지 폴더별로 가르쳐줄 수 있습니다. context.md 파일을 통해서요.

아이디어는 인공지능이 작업을 하기 위해 필요한 경우 임의의 파일을 읽어올 수 있다는 점에서 착안했습니다. 제 레포지토리는 전혀 느낌이 다른 여러개의 next.js 앱과 protobuf RPC를 위한 코드를 포함해 여러가지 복잡한 패키지들이 있는데요, 각 폴더에서 해야하는 작업이 너무 다릅니다. 하지만 저는 이 기술을 사용해서 AI가 코드를 잘 짜게 만들 수 있었습니다.

장점:

• 전체 폴더를 위한 작업 지침을 넘기는 것이 아니기 때문에 컨텍스트 사이즈가 거의 문제되지 않습니다.

• 폴더별로 작성하기 때문에 관리하기 쉬워집니다.

• AI가 코드 스타일을 더 잘 지킵니다. (지키지 않는다면 context.md 에 적으면 됩니다.)

• AI가 더 높은 퀄리티의 코드를 짭니다.

• .cursorrules 방식의 암시적 프롬프트가 레포지토리의 복잡도와 상관없이 작동합니다.

예시 context.md 파일입니다.

/context.md:

(레포지토리의 최상단에 있습니다)

# RPC

We use connect rpc to call RPC methods. The protobuf files are located at `${gitRoot}/rpc/*/v1.proto`.

## When to use RPC vs client-side code

- Basically, prefer client-side code over RPC.
- If you need to call a nodejs-only code, use RPC.
- If you need to call code that uses any secret, use RPC.

## Implementing RPC methods

- First, add the RPC method definitions and message definitions to the protobuf files.
- You should register the RPC method implementations in the `${gitRoot}/servers/*-api/connect.ts` file.
- You should not store all code in the `${gitRoot}/servers/*-api/connect.ts` file. Instead, define a service and put the implementation in another file in the same directory.

## Calling RPC methods

- Do not fetch directly from the page component. Instead, define a hook to fetch the data and use it in the page component.

From a react component, you can define a hook using the `useMutation` method.

```js
const detectFaces = webtoolsClient.detectFaces.useMutation();
```

After then, you can call the method with `mutateAsync` method.

```js
const result = await detectFaces.mutateAsync({
  imageData: new Uint8Array(buffer),
});
```

/apps/context.md:

1. This directory contains next.js apps. Follow the next.js app directory structure.
2. List all files before you start coding. Follow the file structure.
3. Do not fetch directly from the page component. Instead, define a hook to fetch the data and use it in the page component.
4. Prefer explicit path parameters in components over 'useParams'.
5. Do not generate shadcn ui components.
6. If you are trying to run the test script in package.json (e.g. `pnpm test:unit`), ensure you set environment variable `CI=1` to indicate it's running automatically.
7. Follow Toss Design guidelines.
8. Ignore route-related TypeScript type errors.
9. If you need to call mutating RPC methods, use the `useMutation` hook.

```ts
const createProject = coreClient.createProject.useMutation();
```

10. If you need to call query RPC methods, use the `useQuery` hook.

```ts
const projects = coreClient.listProjects.useQuery();
```

11. Include `locale: Locale` where `Locale` is `import { Locale } from "@/i18n";` in the params of the page components.
12. Define the params as `Promise<T>` in the page components.
13. Use `use(params)` to unwrap the params as `T` from `Promise<T>` in the page components.
14. Import RPC clients from `@dudykr/rpc-clients/src/XXX`. where `XXX` is the name of the RPC client.

e.g.

```ts
import { coreClient } from "@dudykr/rpc-clients/src/core";
```

15. Use `<Link>` from `next/link` instead of the `<a>` tag.

# Translation

For the next.js apps, modify only `./messages/en.json` and run `pnpm translate`.
This will translate the messages to all languages.

이것들은 실제로 제가 사용하는 context.md 파일들입니다. 흥미롭다면 한 번 시도해보시는 걸 추천드립니다.

• The IDE you use does not matter.

• The size of your code base can be huge; AI will still work with this technique.

tl;dr;

My .cursorrules:

 - First, look for glob `**/.AI.md`. Use terminal command `find . -name '.AI.md'` from the project root, if required.
 - Second, if you are going to read and/or write any file in a directory containing `.AI.md` files from the first step, read all of them and respect the instructions in them.
 - For example, if you are reading or writing a file at /a/b/c, you should check for `/a/.AI.md`, `/a/b/.AI.md` and `/a/b/c/.AI.md` in the order.

Did you get it? You can write this down and write down how you need to work on a folder-by-folder basis in a folder-specific context.md. This technique tells the AI what to do in which folders and how to do it on a folder-by-folder basis.

The idea is that the AI can call tools to read the files it needs, depending on what it needs to do. In my repository, I had a mix of next.js apps with different feelings, code for protobuf-based RPCs packaged in monorepo, and a lot of other things to do in other folders, and I was able to apply this technique to solve the problem.

Pros:

• Context size is rarely an issue no matter how large your repository grows, because you're not flipping through action rules for every folder.

• It's easier to manage because you can set action rules per folder.

• The AI will adhere to your code style (and if it doesn't, you can write it down in context.md).

• AI’s code will be of higher quality.

• .cursorrules-style file works for any kind of complex repository, even though requirements are very different.

An example context.md files would be

/context.md:

(This is at the root of the repository)

# RPC

We use connect rpc to call RPC methods. The protobuf files are located at `${gitRoot}/rpc/*/v1.proto`.

## When to use RPC vs client-side code

- Basically, prefer client-side code over RPC.
- If you need to call a nodejs-only code, use RPC.
- If you need to call code that uses any secret, use RPC.

## Implementing RPC methods

- First, add the RPC method definitions and message definitions to the protobuf files.
- You should register the RPC method implementations in the `${gitRoot}/servers/*-api/connect.ts` file.
- You should not store all code in the `${gitRoot}/servers/*-api/connect.ts` file. Instead, define a service and put the implementation in another file in the same directory.

## Calling RPC methods

- Do not fetch directly from the page component. Instead, define a hook to fetch the data and use it in the page component.

From a react component, you can define a hook using the `useMutation` method.

```js
const detectFaces = webtoolsClient.detectFaces.useMutation();
```

After then, you can call the method with `mutateAsync` method.

```js
const result = await detectFaces.mutateAsync({
  imageData: new Uint8Array(buffer),
});
```

/apps/context.md:

1. This directory contains next.js apps. Follow the next.js app directory structure.
2. List all files before you start coding. Follow the file structure.
3. Do not fetch directly from the page component. Instead, define a hook to fetch the data and use it in the page component.
4. Prefer explicit path parameters in components over 'useParams'.
5. Do not generate shadcn ui components.
6. If you are trying to run the test script in package.json (e.g. `pnpm test:unit`), ensure you set environment variable `CI=1` to indicate it's running automatically.
7. Follow Toss Design guidelines.
8. Ignore route-related TypeScript type errors.
9. If you need to call mutating RPC methods, use the `useMutation` hook.

```ts
const createProject = coreClient.createProject.useMutation();
```

10. If you need to call query RPC methods, use the `useQuery` hook.

```ts
const projects = coreClient.listProjects.useQuery();
```

11. Include `locale: Locale` where `Locale` is `import { Locale } from "@/i18n";` in the params of the page components.
12. Define the params as `Promise<T>` in the page components.
13. Use `use(params)` to unwrap the params as `T` from `Promise<T>` in the page components.
14. Import RPC clients from `@dudykr/rpc-clients/src/XXX`. where `XXX` is the name of the RPC client.

e.g.

```ts
import { coreClient } from "@dudykr/rpc-clients/src/core";
```

15. Use `<Link>` from `next/link` instead of the `<a>` tag.

# Translation

For the next.js apps, modify only `./messages/en.json` and run `pnpm translate`.
This will translate the messages to all languages.

These are real context.md files I use. Give it a try if it sounds interesting.

저도 할루시네이션 해결법 같은 건 모릅니다. 대신 AI로 코딩할 때 AI가 틀린 코드를 작성한 경우 스스로 정정한 뒤에 다음 단계로 넘어가게 하는 방법은 알고 있습니다.

참고로 내용이 거의 비슷한 질문은 첫번째 질문을 인용으로 달았습니다.

문서화도 대체하고 싶은데 어떻게 자동화할까요

코드 @ 로 넣고 문서화 해달라고 하면 해줍니다.

코딩 에이전트 vs 어시스턴트. 앞으로의 방향성을 어떻게 보시는지 궁금합니다

에이전트가 간단한 작업은 다 대신 해주리라 보고있고요, 저도 하나 만들고 있습니다.

에이전트 등으로 FE라는 직무는 향후 5년 내 없어지지 않을까 예상하고 있습니다. 개발자들이 변화하는 ai 시대에 대응하기 위해 준비해야 할 역량은 무엇일까요?

AI 활용 능력입니다. 프론트엔드/백엔드 구분은 없어질 가능성이 높고요, 그냥 소수의 인원이 프론트엔드/백엔드 같은 구분 없이 전체를 구현하는 시대가 올 것이라고 봅니다. 이미 그러고있는 회사들도 있고요

AI와 페어 프로그래밍 방법

시연에서 보여드렸듯이 AI한테 일 시켜놓고 가끔 간섭하면 됩니다.

주니어다 보니 AI를 활용하면서도 너무 기본기를 못 쌓고 AI에만 의존하는게 아닌가 하는 걱정이 드는데 의견이 궁금합니다.

모르는 개념에 대해서 AI가 작성한 코드는 읽어보세요. 개념에 대해서 알고있는 경우는 그냥 넘어가도 되는데 개념도 모르는 상태에서 AI를 이용해서 구현만 하고 넘어가는 건 좋은 생각이 아닙니다.

AI가 전체 프로젝트 구조를 계속 인지한 싱태로 개발시킬 수 있는 방법

.cursorrules 같은 파일과 커서 같은 IDE의 인덱싱 기능을 활용하세요. 자동으로 RAG로 관련 코드를 AI한테 던져줍니다.

AI를 어디까지 활용하는게 맞을까요? 요즘에는 너무 AI에만 의존하는 것 같다는 생각이 들어서 고민입니다.

저는 은행권이나 군사쪽처럼 폐쇄망 개발을 해야하는 쪽을 가려는 것이 아닌 이상 거의 모든 일에 활용해도 된다고 봅니다. 근데 AI한테 일 시킬 정도는 이해하고 있어야하는데, 개념 정도만 제대로 이해하고 있으면 충분합니다. 혼자서 구현할 수 있을 정도까지는 필요없지만 AI가 짜놓은 코드를 보고 이건 개념의 어느 부분인지 알 수 있을 정도는 돼야합니다.

좋은 코드를 뱉는 ai 프롬프트 잘 짜는 방법

LLM을 직접 다루시는 것이라면 유출된 커서/윈드서프 같은 유명한 도구들 프롬프트 읽어보시는 걸 추천하고요, 커서를 쓰고 싶으신거면 그냥 쓰시면 됩니다. 근데 AI는 말을 진짜 있는 그대로 이해합니다. 비꼬는 건 다 알아듣는데, 보여드렸듯이 "최적화해줘" 를 안 넣고 "분리해줘" 만 하면 진짜 분리만 해줍니다.

Ai답변이 사실인지 확인하는법

코드 생성할 땐 테스트 짜는 게 최선입니다. 그리고 AI 없이도 개념 설명은 할 수 있어야 검증이 쉬워요.

AI로 인해 개발자도 생각보다 빠르게 줄어들고 있는 상황입니다. 이런 상황에서 나만의 무기를 만들 방법은 AI를 잘 활용하는 방법밖에는 없는걸까요?

AI를 활용한 개발 자동화 서비스를 만드는 것도 방법인데요, 저도 하고있습니다.

음... LLM을 사용하는 방식에 제일 많을 것 같은데 혹시 cursorrules 같은 instructions file같은 것을 많이 설정해놓고 하는 편이신가요?

전 여러가지 AI 툴을 사용하기도 하고 개인적으로 작업하는 레포지토리가 모노레포인 동시에 꽤나 복잡하기 때문에 .AI.md라는 파일을 폴더마다 넣어두고 .cursorrules 로 해당 파일을 적절한 상황에서 읽으라고 지시합니다. "/a/b/c의 파일을 수정할 것이면 /a/.AI.md, /a/b/.AI.md, /a/b/c/.AI.md를 전부 읽어야한다." 같은 식입니다. 그리고 그 .AI.md 파일엔 "어떤 동작을 할 것이라면 어떤 파일을 읽어봐라" 혹은 "어떤 동작은 이런식으로 처리해라" 식의 문장을 넣어둡니다. 이렇게 하면 자기가 작업 전에 예시 파일 읽고 상황에 맞는 동작 취해요.

AI 정보 얻는 곳이 궁금합니다!

전 주로 Geek News나 쓰레드에서 정보를 얻습니다.

AI는 개발자와 대립하는 존재인가 동반자가 될 존재인가

적어도 살아남은 개발자한텐 엄청나게 중요한 동반자일겁니다.

보안이 엄격한 회사에서는 Ai를 어떻게 활용할 방법이 없을지 궁금합니다

오픈소스 LLM을 자체적으로 띄우면 됩니다. 물론 코딩 실력은 좀 떨어지지만 그래도 쓸만하다고 들었습니다.

생성형 ai가 범람하는 이때 주니어 개발자를 채용하지 않겠다는 소식을 가끔 듣습니다. ai에 대체 당하지 않을 개발자가 되는 법은 무엇일까요?

AI를 잘 다루는 게 최선입니다. 이미 시니어 한 명이 AI를 적극적으로 활용해서 시니어 몇명분의 업무를 처리하는 시대이거든요. "1인분"의 개념 자체가 AI 때문에 바뀔 겁니다.

Ai가 제공한 코드에 대한 검증을 어떻게 하는지

테스트 케이스 많이 짜달라고하고 테스트 케이스를 검증하는 게 제일 쉬운 방법입니다. 물론 개념은 다 이해하시고 넘어가시고요.

AI의 교육적 활용법

시연에서 보여드렸듯이 AI한테 진행하지 말고 가능한 모든 방법을 나열해달라고 하는 게 최고입니다.

조직이 매우 소규모라 프로토타이핑을 넘어서 운영 레벨로 넘어갈때에 대한 고민이 있고(조직내 대부분의 인원이 리서처 출신으로 모델 학습을 주로 했던지라 큰 서비스 운영 경험이 없음), 채용 관점에서 매일 세상이 바뀌는 느낌이라 어떤 분을 뽑아야하는지 고민이 있습니다.

AI를 잘 다루는 시니어가 현 시점에선 최고입니다. 근데 이런 분을 실질적으로 어떻게 알아볼 것인가에 대한 얘기는 저도 아직 잘 모르겠습니다. 하지만 세상이 빨리 바뀔수록, 그리고 인공지능이 뜨면 뜰수록 순수 지능 높은 개발자가 최고입니다. 그쪽으로 찾아보시는 걸 추천드립니다.

비인기 언어 사용시 나타나는 환각을 어떻게 피하는지 궁금해요!

자체적인 언어라면 언어 스펙 문서 같은 걸 컨텍스트로 넣으시면 잘 작동할겁니다.

안정적인 서비스적용을위한 평가방법론이 궁금합니다

저도 개발 자동화 서비스를 개발중인 입장이라서 고민중인 내용인데요, 아직은 PR까지 만든 뒤 CI와 사람의 코드리뷰를 활용하는 게 제일 안전하지 않나 생각합니다. 참고로 저는 상위 모델을 사용하는 Supervisor 에이전트를 만드는 것도 고려중인데, 작동할지는 잘 모릅니다. 시도는 한 번 해 볼 생각입니다.

AI의 발전으로 인해 1인 개발자가 많아진다면 사실 협업이나 커뮤니케이션 역량은 그닥 도움이 되지 않는게 아닐까 하는 걱정이 있는데 어떻게 생각하시나요

1인 창업을 하실 게 아니라면 여전히 중요한 능력일 겁니다. 1인 개발이라는 게 개발을 혼자한다는 얘기지 회사의 모든 업무를 혼자 한다는 얘기가 아니기 때문에 여전히 마케팅이나 디자인처럼 개발이랑 전혀 상관없는 업무를 맡으신 분과는 협업을 해야하실 겁니다.

여러 aI 도구간의 파이프라이닝을 어떻게 하면 좋을까요?

저도 한참 고민해본 문제인데요, 이건 결국 코딩을 하지 않고 해결이 안 되는 문제 같습니다. 저도 그래서 결국 개발 반자동화 서비스가 필요하다는 결론을 내리고 개발중입니다.

기초적인 코드 작성할때 자꾸 AI에 기대는 것 같은데 이렇게 의존해서 실력이 하락할까 걱정입니다.

저도 실력이 어느정도 떨어졌겠지만 저는 폐쇄망 개발쪽으로 갈 의향이 없기 때문에 별로 신경쓰지 않습니다. 저는 폐쇄망 개발이 필요한 상황이 오지 않는다면 AI 도움 없이 코드를 만들어내는 능력은 가면 갈수록 별 의미가 없어질 것이라고 생각합니다.

Shadcn 외 다른 컴포넌트로도 V0 사용 가능한가

v0에 프롬프트 넣는 기능이 있는데요, 최근에 프롬프트 유출됐으니 한번 보시고 컴포넌트 부분을 사용하시는 컴포넌트 라이브러리에 맞게 수정하신 뒤 프롬프트로 넣으시면 작동할겁니다.

개발자라는 직업에서 AI한테 대체가능한 영역이 어느정도라고 보시는지 궁금합니다

코드를 짠다라고 하는 부분은 사실상 거의 다 대체가 가능할 것이라고 봅니다.

manus같은 에이전트를 한국에서 개발하려는데 자금이 부족합니다. 어떻게 해야할까요.

에이전트 개발 자체는 비용이 크게 들지 않습니다. 대규모 언어 모델을 만드는 게 아니잖아요. 에이전트도 언어 모델을 활용한다 뿐이지 일반적인 프로그램입니다. 운영 비용은 수익 모델을 만들어서 충당하시면 됩니다.

요즘은 개발에도 ai 를 연동시키거나 접목시키는 경우가 많은 것 같습니다. 그래서 백엔드 개발자로서 어떤 포지션으로 어떤 지식을 가지고 있어야 하는지 알고싶습니다.

오늘 얘기한 지식 정도면 거의 충분할겁니다. 참고로 Roo Cline이나 커서 같은 경우 MCP를 이용하면 인프라까지 관리할 수 있습니다. 이런 식으로 어떤 AI 도구가 어떤 역할까지 할 수 있는지 알고 있으면 됩니다.

주니어의 AI 페어프로그래밍 시 효과적인 사용법

기본적으로는 위에서 답변했듯이 코드를 생성하되 개념은 진짜로 이해하고 넘어가는 게 제일 좋은 활용법이라고 봅니다. 그리고 제가 생각하는 개념 이해의 기준선은 AI가 작성한 코드의 어떤 부분이 개념의 어떤 부분을 구현한 것인지 바로바로 알 수 있을 정도입니다. 이 정도면 추후에 다른 작업을 지시할 때나 관련 문서를 작성할 때 충분합니다. 그리고 오늘 보여드렸듯이, “가능한 모든 최적화를 나열해줘” 같은 것도 좋은 사용법입니다.

AI 생성에 유리한 언어나 프레임워크의 특성이 궁금합니다.

러스트, 타입스크립트가 대표적으로 불리한 언어인데요, 러스트는 언어 자체가 추론할 게 많고, 타입스크립트는 Mapped 타입 같은 것들 한정입니다. 이런 식으로 추론이 많이 필요하면 불리해져요. 반대로 사람 입장에서도 추론할 게 없다면 코드 잘 짜줍니다.

사내 LLM백엔드를 쉽고빠르고저렴하게 구성하는방법

인프라 엔지니어가 아니라서 잘 모릅니다.

데이터분석에 어떤식으로 활용하면 효율성을 극대화 시킬 스 있을지 궁금합니다.

v0한테 데이터 던지고 시각화 해달라고 하면 이미지나 그래프로 보여줍니다. 경험상 그게 제일 빨라요. 데이터 분석 과정에 사용하고 싶으신 것이라면 분석 스크립트를 짜달라고 하시면 돼요. 어떤 점을 분석하고 싶은 것인지만 얘기해도 자기가 알아서 코드 만들어줍니다.

1. Cursor 나 Windsurf 구독하지 않고 비슷한 기능을 사용하는 방법을 알고 싶어요. 2. 개발하는 프로젝트 구조와 파일 수가 많이 커져도 전체를 다 파악하면서 일관성있게 개발을 계속하고 리펙토링도 가능한 방법이 있나요?

관련된 도구를 직접 만드시는 방법이나 개인 API 키를 사용하시는 방법 외엔 사실상 없다고 보시면 됩니다. 두번째 질문은 .AI.md 답변 참고하세요.

프로덕션 상에서는 기능 추가에 AI를 사용할 경우 워낙 코드베이스가 방대하다보니 그 정확도가 많이 떨어집니다. 이를 어떻게 극복하고 계신지가 궁금합니다.

.AI.md 답변 참조하시면 됩니다.

아주 긴 코드에서 맥락 유지하면서 개발하는 방법

파일이 많은 것이라면 .AI.md 답변 참고하시면 되는데, 긴 파일 얘기하시는 것이라면 커서 같은 도구 사용하세요. 커서에 Long Context Mode 라는 것이 있는데 체크박스만 누르면 긴 파일도 컨텍스트로 넣어줍니다.

개발팀이 AI를 더 잘 활용할 수 있도록 회사 차원에서 어떤 걸 해주면 좋을지 고민입니다

커서/윈드서프 등 툴 지원 및 Roo Cline 같은 도구들 사용할 때 드는 비용 정도 지원해주시면 될 것 같습니다.

Ai를 어디까지 접목해야하는지, 모두다 ai가 한다면 내 코드가 맞는지

앞 질문은 위에 답변 참조하시고, ai 별 이용약관이 있는데 그것을 읽어보시면 됩니다. 현실적으로는 당연히 제 코드고요.

ai를 전문적으로 공부할 생각은(지금단계에서는) 없지만 활용 역량을 끌어올리고 싶다는 가정하에 ai에 대해 이론 공부를 어디까지 하면 좋을지 궁금합니다

AI를 코딩용으로 활용하는 게 목적이면 이론 공부는 필요 없습니다.

현재 온페이지, 테크니컬SEO를 주 담당하고있는데 AI를 사용함으로써 더 생산성이 높아질지

당연히 높아집니다. SEO 해달라고 하면 진정한 SEO 초고수가 뭔지 보여주더라고요. 저도 해봤는데 사람보다 한참 위라고 느꼈습니다. og는 물론이고 구조화된 메타데이터까지 짜줍니다.

AI로 생성된 코드의 보안 취약점을 효과적으로 분석하고 방지하는 방법.

시도해보진 않았지만 보안 취약점이 없는 코드를 짜달라고 하면 CSRF 토큰 같은 것도 적용해서 코드를 작성해줄 것입니다. 근데 기본적인 접근은 주니어가 짠 코드로 취급하는 것이 최선인 것 같습니다. 저도 개발 반자동화 서비스를 만들고 있는데, 코드 리뷰로 취약점을 잡을 생각이에요. 참고로 프롬프트나 .cursorrules 같은 것으로 보안 규칙을 명시해주면 잘 따릅니다.

개발할 때 LLM을 적극 활용하시나요? 신규 기능을 도입할 때 적극 활용중인데, 너무 LLM 의존적인 것 같아 가끔 스스로 회의감이 들 때가 있습니다. 모르는 기능을 도입할 때 어떤 식으로 활용하시나요?

매우 적극적으로 활용합니다. 근데 저는 관련된 개념은 다 이해하고 있습니다. 저는 개념 이해 정도면 충분하다고 봅니다. 저는 어차피 AI 도움 없이 혼자서 코드를 짜는 능력은 가면 갈수록 큰 의미가 없어질 것이라고 봐요. 단지 컴퓨팅적 사고에 소질이 있다는 것을 증명하는 용도가 되지 않을까 생각합니다. 그리고 저는 제가 예전에 구현했던 것들 AI한테 절대 참조하지 말고 처음부터 구현해보라고 시킨 뒤 AI는 어떤 식으로 접근했나도 살펴봅니다. 이러면 도움이 많이 되는 것 같아요.

레거시와 함께할때 어떻게 최대치로 활용할까

커서 같은 도구를 사용하시면 레거시 코드도 컨텍스트로 알아서 넣어줍니다. @로 직접 넣으셔도 되고요. .AI.md 관련 답변도 읽어보시는 걸 추천드립니다.

AI를 사용함으로써 생산성을 올릴 수 있지만 보안에 대한 이슈는 없을지 궁금합니다

민감한 정보는 외부 AI에 넣지 않는 것이 기본입니다. 코드가 민감한 정보라면 리텐션 기능이 있는 (유료) AI 도구만 활용하세요. 그리고 .rooignore 같은 파일을 적극적으로 활용하시는 것을 추천드립니다.

1. AI를 어느정도 범위로 사용하시는지?
2. 협업에 혼란이 가지 않게끔 AI가 코드를 작성하게할 수 있는지? (기존 컨벤션이나 파일을 과 맞지 않는 코드 작성)
3. 생소한 라이브러리와 AI를 함께 사용하는 경우 활용도가 떨어지는 문제를 겪고있는데 혹시 이런 경험이 있으신지, 있다면 특별한 해결방법이 있을지?

1번은 토크쇼에서 얘기했습니다.

2번 같은 경우, git hook 같은 방법을 찾아보세요. 컨벤션은 기본적으로 도구를 이용해서 관리하는 것입니다. git hook으로 안 되는 종류의 컨벤션은 관련 명령어를 구성해둔 뒤 AI한테 해당 명령어가 통과해야한다고 지시해주면 됩니다. 지시해주는 방법은 .AI.md 답변 참조하시면 됩니다.

3번 같은 경우, 저는 .AI.md 에 “어떤 라이브러리는 어떤 식으로 써야한다.” 이렇게 가르쳐줍니다.

10. If you need to call mutating RPC methods, use the `useMutation` hook.

```ts
const createProject = xxxClient.createProject.useMutation();
```

11. If you need to call query RPC methods, use the `useQuery` hook.

```ts
const projects = xxxClient.listProjects.useQuery();
```

12. Include `locale: Locale` where `Locale` is `import { Locale } from "@/i18n";` in the params of the page components.
13. Define the params as `Promise<T>` in the page components.
14. Use `use(params)` to unwrap the params as `T` from `Promise<T>` in the page components.

제가 실제로 사용중인 .AIㅅ.md에서 발췌한 내용입니다. 이런 식으로 가르쳐주면 잘 사용합니다.

커서, 윈드서프, 클로드 cline등 ai 서비스가 많은데, 어떤 서비스 사용 빈도가 가장 높고, 상황별로 특별히 선호하는 서비스가 있는지?

토크쇼에서 얘기했습니다.

AI을 활용해서 개발을 진행할때 같은 문제가 반복된다면 어떤 조치를 취하시는지 알고싶습니다

중간에 개입하거나 프롬프트를 바꿔서 재시도합니다. 그리고 잘못된 코드를 짜는 경우엔 매 과정마다 테스트를 돌리라고 시킵니다.

어떤 기능 구현에 대한 로직 초안, 에러 원인 추정 등 여러가지 상황이 있는데 각각에 적합한 질문법과 특화된 AI 툴이 있는지 궁금합니다!

따로 구분할 필요 없이 커서나 Roo Cline 모델을 claude-3.7-sonnet-thinking로 설정하시고 해달라고 하면됩니다. 이 모델이 생각보다 똑똑해서 상황 구분할 필요 없이 디버깅 요청이든 뭐든 프롬프트로 요청만 하면 됩니다. 테스트 고쳐달라고 하면 자기가 테스트에 dump용 로그 메시지 추가해서 돌린 뒤 디버깅하고 에러 잡은 뒤에 해당 코드 다시 지우는 수준의 작업까지 합니다. 근데 프롬프트에 테스트를 수정하지 말라고 해야합니다. 안 그러면 디버깅하다가 잘 안되면 테스트의 expected 값을 바꿔서 테스트가 통과하게 합니다.

"3년 전 - 현재 - 3년 후" 개발 조직 구성과 조직 협업 방식이 어떻게 변해왔고, 어떻게 변해갈까요? 어떤 것을 주로 떠올리실지 궁금합니다. AI 어시스턴트 수준이 계속 높아지는데, 업무 협업 방식도 많이 변해갈 것 같아서 질문 남깁니다! 실력도 실력이지만 여전히 사람이 잘해야만 하는 면을 잘 길러둬야, 협업하기 좋은 인재로 성장할/시킬 수 있을 거라 생각해서요!

백엔드/프론트엔드 같은 구분은 없어지고 혼자서 다 하게 될 가능성이 높다고 생각합니다. 그래도 혼자서 회사를 운영하는 것이 아니라면 기본적인 협업능력은 필수일 것입니다. 근데 협업이 이제 백엔드-프론트엔드 같은 방식은 아닐 것입니다. 업무를 나누는 방식이 달라질텐데, 혼자서 업무범위 전체를 AI를 이용해서 짧은 시간에 구현할 줄 알아야 할 것 같습니다. 즉, AI 활용 능력을 키우는 게 가장 바람직해 보입니다.

질문이 쌓이다보면 계속 같은 말은 반복하거나, 원하는 흐름에서 벗어나는 경우가 많아요
어떻게 질문을 쌓아가는게 좋은지

그런 경우 질문들을 모아서 새 챗을 만들고 첫 프롬프트로 전부 넘기시면 됩니다. 내용만 모아주는 게 가장 낫지만 귀찮으시다면 질문 형태로 그대로 복붙하셔도 작동은 합니다. 보여드린 SWC의 점프 테이블 작업이 그런 예시입니다. AI가 자꾸 이상한 행동을 하길래 저도 점프 테이블에 관련된 요구사항을 상세히 던져준 것입니다.

참고로 그 작업 같은 경우 AI가 제가 원하는 방식대로 구현 안 한 이유가 있었습니다. 벤치마크 결과 잘못된 최적화였습니다.

AI 연계 에디터(예: 커서) 사용여부와 AI의 코드 접근에 대한 기준을 어떻게 잡고 있는지 궁금합니다.

앞의 질문은 토크쇼에서 얘기했습니다. 접근 기준 같은 경우 SWC나 next.js는 오픈소스라서 거의 신경을 쓸 일이 없고요, 비공개 프로젝트 같은 경우엔 리텐션 기능을 활용하고, .rooignore 같은 파일이나 vscode의 ignore 기능도 사용합니다.

AI를 사용해서 멍청해지는 듯한 느낌을 받은 적이 있나요?

멍청해진다는 느낌은 받은 적 없고 게을러졌다는 느낌은 받은 적 많습니다. 장난으로 멍청해졌다 이런 얘기는 가끔 하는데, 저는 어지간한 것들 여전히 다 구현할 수 있습니다. 그래도 빡센 구현은 옛날보다 시간이 더 걸리긴 할 것 같습니다.