4/21/2026

AI 시대의 소프트웨어 개발 시간 예측은?


프로젝트를 진행하면서 여러가지 생각이 든다. 이제까지는 소프트웨어 개발에서 공수산정을 할때, 생산성의 단위는 사람이었다. 개발자는 코드를 생산하고, 프로젝트는 그 생산량을 기준으로 계획되었다. 그래서 공수는 "사람 x 시간"이라는 공식으로 산출하였다.

사실 위 방식은 안정적인 방법은 아니었다. 코드 라인 수(LOC)는 기능의 복잡도를 설명하기 어려웠기에 스토리포인트나 기능 점수(Function Point)와 같은 대안이 등장했다. 그러나 이 역시 동일한 전제를 유지했다. 작업량은 측정 가능하며, 그 작업량은 결국 사람의 노력으로 환산된다.

생성과 생산의 분리

AI가 코드 생성에 개입하면서 이 전제가 흔들리기 시작했다. 코드는 더 이상 개발자의 시간만으로 만들어지지 않는다. 생성은 AI가 담당하고, 개발자는 그 결과를 다룬다.

이 변화는 단순한 생산성 향상이 아니라 생산의 구조 자체가 바뀌는 것이라고 생각한다. 일반적으로 코딩은 생성, 검증, 조정 세 단계로 구분되고 이 단계중 "생성"은 점점 자동화되고, 비용의 중심은 다른 영역으로 이동되고 있다.

생산성의 재배치

최근 여러가지 글들을 읽고 있는데, 일관된 패턴을 보여준다. AI 도구를 사용하는 개발자는 개별 작업 단위에서 더 빠른 결과를 낸다. 그러나 프로젝트 전체 단위에서는 그 효과가 일정하지 않다. 생성 비용은 감소했지만 검증 비용은 증가했다. 레거시를 안고 있는 환경에서는 A to Z를 새롭게 만드는 환경이 아니기에, 검증이 중요하기 때문이다.

즉, 생산성은 증가하는 것이 아니라 재배치되고 있다.

공수의 중심 이동

이 상황은 공수산정의 기준을 바꾼다고 생각한다. 과거에는 생성 비용이 중심이었다. 얼마나 많은 코드를, 얼마나 빠르게 작성할 수 있는가였다.

그러나 지금은 검증 비용 중심으로 이동된다고 생각된다. 얼마나 정확하게 이해하고, 얼마나 안정적으로 수정할 수 있는가다.

이 관점에서 보면 공수는 더 이상 인력의 문제가 아니다. 문제의 복잡도와 검증 난이도의 문제다.

공수를 구성하는 변수의 변화

파트너사의 도움을 받기위해 계약을 할 때, 고려해야 할 포인트들이 생기기 시작했다. 기존 모델은 단순했다.

공수 = 사람 x 시간

AI 환경에서는 위 식이 그대로 유지되지 않는다. 보다 현실적인 형태는 다음과 같은 구조에 가깝다.

공수 = 문제 복잡도 x AI 토큰비 x 검증 비용

여기서 중요한 요소는 아래와 같다.

  • AI 도구 숙련도
  • 작업이 AI를 쓰기에 얼마나 적합한가?
  • AI가 생성한 결과의 품질
  • 기존 시스템과 통합 난이도
  • 검증 및 수정 비용

이 요소들은 기존 모델에서는 거의 고려되지 않았다. 하지만 이제는 공수에 직접적인 영향을 미친다.

RFP 방식의 변화

이제까지 언급한 공수산정의 변화는 RFP에도 영향을 끼친다. 기존 RFP는 텍스트 중심이었다. 요구사항을 문서로 정의하고, 이를 기반으로 제안을 받았다.

하지만 AI 환경에서는 이 방식이 비효율적으로 비친다. 대신 아래와 같은 방식을 고려할 수 있다.

  • 프로토타입 생성
  • UI 및 인터렉션 구현
  • 이를 기준으로 범위 정의

즉, 명세보다 만들고자 하는 결과물이 먼저 나오는 구조다. 이 구조에서는 공수산정도 달라지게된다.

비용 구조의 변화

비용 역시 변화가 생긴다. 인건비 비중은 감소하고, AI 사용 비용과 인프라 비용은 증가하게된다. 가장 중요한 변화는 검증과 품질 관리 비용이다. 이 영역은 상황에 따라 다르겠지만, 레거시가 있는 경우에는 자동화가 어렵고 여전히 높은 전문성을 요구한다. AI가 생성한 결과는 불확실성을 포함한다. 이 불확실성을 제거하는 과정이 새로운 비용이 된다.

마무리

여러개의 프로젝트를 준비하고 있는 이 시점에서 고민이 많다. 그래서 스스로에게 질문을 던진다.

이 작업은 몇 명이 할 수 있는가가 아니라, 얼마나 빠르고 정확하게 안정적으로 결과를 만들 수 있는가?

이 질문에 답하는 방식이 앞으로의 공수산정 모델이 될 가능성이 높다. 지금 진행하는 프로젝트에는 AI 토큰비를 반영했고, 개발자 리소스는 줄어드는 구조로 진행된다. 그리고 앞으로 다가올 프로젝트는 위에서 언급한 인터렉션을 포함한 프로토타입을 제공하는 형태로 준비중이다.

AI를 활용하는 지금 시점에서 고객사나 파트너사 둘 다 모두 공수산정이 기존의 형태를 유지하기가 어렵다고 인지를 하고 준비를 해야한다고 생각한다. 사람 중심의 계산에서 변수 중심의 판단으로 이동하고 있기 때문이다.

References:

4/20/2026

우리는 왜 Agent를 이야기 하고 있는가?

요즘 AI Agent에 대한 이야기가 많다. 툴을 붙이고 모델이 판단하고 다음 행동을 고르고 필요하면 다시 도구를 호출한다. 마치 소프트웨어가 스스로 다음 단계를 정하는 것처럼 보인다.

이 변화는 생각보다 낯설지 않다. 오히려 오래된 소프트웨어의 역사 위에 아주 자연스럽게 이어진 흐름에 가깝다.

과거에도 소프트웨어를 개발할 땐 플로우차트를 그려서 개발을 했었다. 입력이 들어오고, 어떤 판단을 거쳐서 다음 단계로 가고 결과를 내놓는 구조 자체가 이미 하나의 그래프였다.

이 관점에서 접목하면 Agent는 마법이 아니라, 소프트웨어가 흐름을 다루는 방식이 바뀌는 과정에 가깝다.

소프트웨어의 시작은 결국 "순서"였다.

아주 초창기 소프트웨어 개발은 지금처럼 거대하지 않았다. 해야 할 일도 비교적 단순했다. 입력을 받고, 계싼하고, 출력하면 끝이었다. 프로그램은 일종의 절차였다. 한 줄을 실행하고, 그 다음 줄을 실행하고... 조건이 맞으면 분기하고 아니면 다음으로 넘어간다.

이걸 가장 직관적으로 보여주는 것이 플로우차트다. 네모 상자 안에 해야할 작업을 넣고 화살표로 다음 작업을 연결한다. 이 방식은 단순한 시각화 도구가 아니라, 소프트웨어의 본질을 꽤 정확하게 보여준다.

프로그램은 결국 "어디에서 어디로 흘러가는가?"의 문제였기 때문이다.

쉽게 설명하면,

  • 어떤 작업이 있다.
  • 그 다음에 올 수 있는 작업이 있다.
  • 특정 조건이면 다른 경로로 간다.
  • 마지막에는 종료된다.


이 자체가 이미 그래프다. 노드가 있고, 노드 사이를 잇는 방향으로 연결되어 있다.

이 관점은 중요하다. Agent도 결국 이 틀을 벗어나지 않기 때문이다. Agent가 새로워보여도 여전히 무언가를 보고, 다음 행동을 정하고 그 결과를 바탕으로 다시 다음 행동을 정한다. 즉, 여전히 그래프 위에서 움직인다.

시스템이 커질수록 사람은 흐름을 더 엄격하게 통제한다.

처음에는 단순한 절차 프로그램이면 충분했지만, 시간이 지나면서 처리해야 할 작업이 폭발적으로 늘었다. 데이터 파이프라인, 배치 작업, ETL, 머신러닝 학습 파이프라인처럼 순서와 의존성이 중요한 일이 많아졌다.

여기서 등장한 것이 DAG(Directed Acyclic Graph)이다. 방향이 있고, 순환이 없는 그래프라는 의미이다. 즉, 작업 순서와 실행 조건을 명시하는 구조라고 이해하면 된다.

예를 들어 원천 데이터를 일고 -> 정제하고 -> 집계하고 -> 리포트를 만든다와 같은 흐름은 전형적인 DAG다. 하나의 작업이 끝나야 다음 작업이 시작된다. 보통 반대로 되돌아가지 않는다.

소프트웨어가 복잡해질수록 우리는 로직 자체외에 흐름의 관리를 소프트웨어로 만들게 된다. 단순히 기능을 만드는 것이 아니라, 어떤 기능이 언제 어떤 조건에서 어떤 순서로 움직여야 하는지를 정교하게 설계하게된다.

DAG의 본질은 사람이 모든 경로를 설계하는데 있다.

DAG 기반 시스템은 강력하다. 실행 순서를 통제할 수 있고, 실패 지점을 추적할 수 있고, 어느 작업이 어떤 작업에 의존하는지 명확하게 알 수 있다. 장애가 발생하면 어디서 실패를 했는지 찾기도 좋다.

하지만 이 구조는 필요한 전제가 있다. 사람이 경로를 안다는 전제다.
즉, 누군가는 미리 이런 경로를 만들어두어야 한다.

  • 먼저 무엇을 실행할지
  • 실패하면 어디로 갈지
  • 특정 조건이면 어떤 가지로 분기할지
  • 어떤 작업이 끝나야 다음 작업을 실행할지

위에 언급한 내용은 상당히 익숙한 개발 방식이다. 모든 경우의 수를 코드와 규칙으로 먼저 정의하는 방싱이다. 이게 잘 설계된 소프트웨어가 안정적인 이유도 여기에 있다. 컴퓨터는 미리 정해놓은 규칙을 가장 잘 따르기 때문이다.

문제는 현실이 점점 이런 방식에 딱 맞춰서 되지 않는다는 점이다. 우리가 다루는 일 중에는 사전에 모든 경로를 정의하기 어려운 것이 많기 때문이다. 예를 들면 아래와 같은 것들이다.

  • 사용자의 질문 의도를 먼저 해석해야 한다.
  • 문서를 읽고 다음 행동을 정해야 한다.
  • 오류 메시지를 보고 어떤 도구를 쓸지 선택해야 한다.
  • 중간 결과를 보고 계획 자체를 수정해야 한다.

물론, 이런 것들은 전통적인 DAG로 만들 수 있다. 그러나 코드가 길어지고, 조건문도 많아지게 된다. 여기서 의문이 생긴다.

"정말 사람이 모든 경로를 미리 정해야 할까?"

Agent는 경로를 사람이 전부 정하지 않아도 된다라는 발상에서 시작된다.

LangGraph는 워크플로우와 Agent를 구분한다. 워크플로우는 미리 정해진 코드 경로를 따르지만 에이전트는 스스로 프로세스와 도구 사용을 정의하는 동적 구조라고 설명한다.

즉, 워크플로우는 다음 단계가 이미 정해져 있는 시스템이고, 에이전트는 지금 상태를 보고 다음 단계를 고르는 시스템이다.

둘 간의 차이는 생각보다 크다. 워크플로우 방식에서는 사람이 경로를 먼저 정해놓아야 한다. 에이전트 방식에서는 사람이 할 수 있는 행동들과 목표를 정의하고, 실제 경로 선택은 모델에게 맡기는 구조다.

예를 들면,
워크플로우:

  1. 질문이 들어온다.
  2. FAQ를 찾는다.
  3. 없으면 상담원에게 넘긴다.

현실 세계의 문제가 위 정도로 깔끔하다면 가능하다.

에이전트:

  1. 질문이 들어온다.
  2. 모델이 질문 의도를 해석한다.
  3. 지식베이스 검색이 맞는지, 다른 요청인지 판단한다.
  4. 필요한 도구를 호출한다.
  5. 결과를 보고 다음 행동을 정한다.

즉, 전체 흐름은 그대로인데, 그때그때 어떤 선을 탈지 여부를 모델이 고른다. 그래서 에이전트는 그래프를 버린 새로운 개념이라기보다 그래프 위에서 의사결정 주체가 바뀐 구조라고 보는 쪽이 이해하기 쉽다.

에이전트 시대라기보다, 소프트웨어의 무게중심 이동에 가깝다.

많은 에이전트에 대한 이야기들이 마치 기존 소프트웨어가 끝나고 완전히 다른 무언가가 시작된 것처럼 보이게 만든다.하지만 실제로는 무게중심의 이동에 더 가깝다.

예전에는 사람이 경로를 정의하고, 컴퓨터는 정해진 경로를 빠르고 정확하게 실행했다.
지금은 사람은 목표, 제약, 도구, 상태등의 구조를 정의하고 모델은 현재 상태를 보고 다음 행동을 고른다. 시스템은 그 선택을 안전하게 실행한다.

LangGraph가 스스로를 long-running, stateful agents를 위한 오케스트레이션이라고 설명하는 것도 같은 맥락이다. 에이전트가 오래 실행되고, 상태를 갖고, 디버깅과 배포를 고려해야 한다는 말은 결국 에이전트도 소프트웨어 엔지니어링 대상이라는 뜻이다.

AI가 판단을 돕는다고 해서 시스템 설계가 덜 중요해지는 것은 아니다. 오히려 더 중요해진다. 예전에는 정해진 것만 실행하는 시스템을 만들면 됐지만, 지금은 상황에 따라 다르게 움직일 수 있는 시스템을 다뤄야 하기 때문이다.

이걸 가장 쉽게 비유하면 자동차 네비게이션과 비슷하다. 예전에는 종이 지도에 가까웠다. 출발 전 미리 경로를 다 그린다. 어디서 좌회전할지, 어디서 직진할지, 어디서 우회전할지 사람이 먼저 정한다. 이게 전통적인 워크플로우와 비슷하다.

에이전트 방식은 실시간 네비게이션에 가깝다.
목적지는 정해져 있지만, 막히는 길이 있으면 우회하고, 사고가 있으면 다른 길을 추천하고, 현재 상황을 반영해서 경로를 계속 수정한다.

여기서 중요한 것은 목적지가 사라진게 아니라는 점이다. 그리고 차량 제어가 없어지는 것도 아니다. 브레이크와 핸들, 도로 규칙, 제한속도는 여전히 필요하다. 단지 길을 고르는 방식이 달라진 것이다.

에이전트 관점에서는 목적지는 목표고, 지도는 컨텍스트고, 갈 수 있는 길은 도구들이고, 네비에기션 엔진은 LLM이고, 차량의 안전장치는 소프트웨어 시스템이다.

이 비유로 보면 에이전트가 왜 신기하지만 결국 소프트웨어 문제인지 이해하기 쉬워진다.

그래서 좋은 에이전트는 LLM이 똑똑해서보다 단단한 시스템으로 감싸면 잘 동작한다.

모델만 좋으면 에이전트가 잘 것이라고 생각하는 분들이 많다. 하지만 실제 운영 관점에서는 대개 반대다. 좋은 모델도 중요하지만 시스템 설계가 부실하면 에이전트는 효율적이지 못하다.

그 이유는 에이전트는 본질적으로 불확실성을 지니고 있기 때문이다. 모델이 잘못 이해할 수 있고, 같은 요청에도 판단이 달라질 수 있고, 도구 호출 순서가 비효율적일 수 있고, 중간 결과를 잘못 해석할 수 있다.

그래서 에이전트가 현장에서 쓰이려면, 밖에서 이를 잡아주는 구조가 필요하다. 대략 이런 것들이 필요하다.

  • 상태를 어디에 저장할지
  • 어떤 도구를 허용할지
  • 실패 시 어디까지 되돌릴지
  • 사람 승인 단계를 어디에 둘지
  • 로그와 추적을 어떻게 남길지

즉, 에이전트는 신비한 존재가 아니라 신뢰성 있는 소프트웨어 시스템으로 다뤄야 한다는 문제인식을 가져야 한다. 에이전트를 잘 만든다는 것은 프롬프트 몇 줄을 잘 쓰는 일이 아니라, 모델이 들어간 소프트웨어를 어떻게 운영 가능한 구조로 만들 것인가의 문제이기 때문이다.

재미있는건 이 변화가 특정 분야에만 머무르지 않는다는 점이다. 데이터쪽에서는 Airflow나 Prefect같은 워크플로우 도구가 여전히 중요하다. 정해진 파이프라인을 안정적으로 돌리는 일은 앞으로도 사라지지 않는다.

반면, LLM이 들어오는 영역에서는 에이전트 오케스트레이션을 전면에 내세운다. 이는 에이전트도 결국 흐름의 문제이고, 따라서 그래프로 모델링 하는것이 유효하다는 의미다.

즉, 세상은 기존 워크플로우를 버리고 에이전트로 완전히 갈아타는 방향으로 움직이기보다는, 정해진 흐름은 계속 워크플로우에 두고, 불확실한 구간만 에이전트로 다루는 혼합형 구조로 가고 있다고 생각하는 것이 현실적이다.

에이전트를 이해하는 가장 좋은 방법은 개발 혁명보다 설계 방식의 진화로 보는 것이다.

에이전트를 둘러싼 담론은 종종 너무 크다. 개발자를 대체한다. 소프트웨어를 새로 쓴다. 사람 없이 돌아가는 회사를 만든다. 같은 이야기가 많다.

에이전트는 소프트웨어를 없애는 기술이 아니다. 소프트웨어 안에서 판단이 들어가는 부분을 다루는 새로운 방법이다.

예전에는 그런 판단을 사람이 미리 규칙으로 넣었다. 이제는 판단을 모델에게 맡길 수 있게 되었다. 그래서 우리는 더 많이 고민해야 한다.

  • 어디까지 맡길 것인가?
  • 어떤 도구를 줄 것인가?
  • 어떤 상태를 기억시킬 것인가?
  • 언제 사람을 개입시킬 것인가?
  • 어떤 실패는 허용하고, 어떤 실패는 막을 것인가?

중요한 것은 AI가 뭘 할 수 있나보다 우리가 어떤 구조를 만들 것인가다.

에이전트는 갑자기 하늘에서 떨어진 개념이 아니다. 플로우에서 시작해, DAG로 정교해지고, 이제는 경로 선택을 모델에게 넘기는 방향으로 진화해온 소프트웨어 역사다.

그래서 생각도 진화해야 한다.

"어떤 모델이 제일 똑똑한가?" 보다,
"우리는 어떤 일을 결정론적으로 둘 것이고, 어떤 일을 동적으로 맡길 것인가?"가 더 중요하다.

"에이전트를 붙일까? 말까?"보다,
"이 시스템 안에서 판단이 필요한 지점은 어디인가?"가 더 중요하다.

이렇게 보면 에이전트는 덜 신비롭지만, 훨씬 실용적으로 보인다.

마무리

어쩌면 우리가 에이전트를 새롭다고 느끼는 이유는, 기술이 갑자기 낯선 방향으로 튄 것처럼 보여서가 아니다. 사실은 오래전부터 이어져 온 소프트웨어의 흐름이 드러났기 때문일지도 모른다.

지금 우리가 만들고 있는 작은 시스템 하나, 작은 판단 하나, 작은 흐름 하나를 설계하는 과정에서 변화는 시작될 것이다. 거대한 선언이나 유행이 아니라...


References:

4/11/2026

AI를 쓰고 있는데, 왜 바뀌지 않을까?

Man On Arrow
Photo by Smart on Unsplash

현재 AI를 쓰지 않는 조직은 거의 없다. 레포트에 따르면 약 88%의 기업이 최소 한 개 이상의 업무에 AI를 활용하고 있다고 한다.

하지만 질문을 하나 던져보면 답이 달라진다.

"그 AI가 조직의 결과를 바꿨는가?"

또 다른 연구에서는 기업의 생성형 AI 프로젝트 중 95%가 실제 성과에 영향을 주지 못했다고 한다. 이건 기술 문제가 아니다.

AI는 이미 작동하고 있다.
작동하지 않는 것은 조직이다.

실패의 본질 - 우리는 AI를 "도입"하고 있다.

AI 프로젝트 실패율은 자료마다 다르지만, 대략 70% ~ 95% 수준이라는 공통된 범위가 나온다.
이 숫자의 핵심은 실패율이 아니라 "실패 이유"이다.
대부분의 실패 원인은 다음과 같다.

  • 기술 문제 X
  • 조직 문제 O

연구에 따르면 AI 실패의 63%는 기술이 아니라 인간, 조직 요인에서 발생한다. 여기서 중요한 차이가 하나 나온다.

도입 vs 전환

  • 도입: AI 도구를 업무에 추가
  • 전환: 업무 자체를 다시 설계

문제는 대부분의 기업이 전환이 아니라 도입을 하고 있다는 점이다.

AX팀 패러독스 - 전환을 하겠다고 하면서 더 멀어진다.

FLowkater 블로그의 "AX Team Paradox" 글에서 매우 중요한 통찰이 하나 제시된다.

AX팀을 만드는 순간, AX는 실패한다.

위 문장은 과장처럼 보일 수 있지만 구조적으로 보면 맞다고 생각된다. 이유는 단순한다.

AX의 본질은:

  • 의사결정 -> 실행 간 거리 축소
  • 중간 레이어 제거

그런데 아래의 조직을 만든다:

  • AX팀
  • AI TF
  • 전환 조직

즉, 단순한 실행 문제를 넘어서 구조적 모순이다라는 점이다.

계층을 줄여야 하는데
계층을 하나 더 추가하는 모양새다.

개인은 변했지만 조직은 변하지 않았다.

현재 기업에서 실제로 일어나는 변화는 대부분이 아래 수준이다.

  • 개발자 -> Claude Code, Cursor, Codex 등 사용
  • 마케터 -> GPT 사용
  • 기획자 -> AI 리서치 사용

즉, 개인 생산성은 올라간다.

하지만 조직 수준에서는:

  • 승인 프로세스 변화 없음
  • 핸드오프 변화 없음
  • KPI 변화 없음

결과적으로 "고도화된 각자도생" 상태가 된다.

이건 MacKinsey 레포트와도 정확하게 일치한다.

AI 성과를 내는 기업은 워크플로우를 재설계한다.

왜 조직은 바뀌지 않는가?

AI 전환이 어려운 이유는 크게 3가지라고 본다.

조직 구조의 문제

기존 조직은 역할 기반이다.

  • PM
  • 기획
  • 개발
  • QA
  • 운영 등

AI는 위 구조를 무너뜨린다. 한명이 기획 -> 개발 -> 테스트를 수행할 수 있게 만든다.
하지만 조직은 그대로 유지된다.

결과적으로 AI는 도입했지만, 병목은 그대로 유지된다.

정체성의 문제

AI 전환은 단순한 생산성 문제가 아니다.

"나는 개발자다"
"나는 기획자다"

이 정체성이 흔들린다. 그래서 서로 가지 않았던 영역을 걸어가야 한다고 가이드하고 있다.
즉, AI는 업무를 바꾸는 것이 아니라, 사람의 역할을 재정의한다.

시스템의 문제 (하네스 부재)

현재 대부분의 기업은 여러 AI 도구를 가지고 있다. 그러나 없는 것이 있다. (물론 있는 기업도 있다.)

"어떻게 같이 일하게 할 것인가?"

이게 바로 하네스(Harness) 문제다.

전환의 본질 - 조직을 다시 설계하는 것

McKinsey에서는 이 문제에 대해 이야기한다. "AI 경쟁력은 기술이 아니라 어떻게 적용하느냐에서 나온다." 그리고 가장 중요한 요소는 "워크플로우 재설계"라고 언급한다.

즉, AI는 기능 자동화 기술이 아니라 조직 구조를 바꾸는 도구다.

새로운 운영 모델

AI 전환의 끝에는 완전히 다른 조직 형태가 나온다. 그 특징은 아래와 같다.

  • 역할 중심 -> 결과 중심
  • 부서 중심 -> 문제 중심
  • 사람 중심 -> 사람 + AI Agent 협업

그리고 가장 중요한 변화는.,

"팀"의 정의가 바뀐다.

단순한 자동화가 아니라 조직 단위 자체의 변화다.

핵심 매커니즘 - 하네스 엔지니어링

AI 전환의 핵심은 모델이 아니다. 물론 모델도 중요하다. 하지만 모든 작업에 동일한 모델을 사용하지 않을 것이다. 이것만큼 비효율은 없으니까...

Orchestration

그래서 하네스 엔지니어링이 필요하다. 구성 요소는 다음과 같다.

  • 역할 정의 (Agent)
  • 워크플로우
  • 메모리
  • 피드백 루프

Zero Human Company - 전환의 끝

AI 전환의 궁극적인 형태는...

  • 사람은 실행하지 않는다.
  • 사람은 설계한다.

즉,

"운영하는 회사" -> "설계하는 회사"

위 개념은 아직 극단적으로 보이지만, 이미 일부 영역에서는 현실이 되고 있다.

실행 전략 - 어떻게 시작할 것인가?

현실적인 전략은 다음에 언급하는 네 가지이다.

AX팀을 만들지 말 것

별도 조직을 만들지 말고, 기존 조직 내에 embedding 해야 한다.

도구가 아니라 워크플로우 설계

AI 도구 도입이 우선시 되는 것이 아니라, End-to-End를 AI기반으로 설계해야 한다.

개인 자동화에서 조직 자동화로

개인 생산성은 이미 어느정도 올라가 있다. 이것을 조직 구조 변화로 확장해야 한다.

역할을 다시 정의

하나의 질문을 해보자.

"AI가 60%를 하면, 남은 40%는 무엇인가?"

마무리

AI는 이미 충분히 발전했다. 문제는 기술이 아니라고 생각한다.

AI는 도입하는 순간 실패하고, 조직을 다시 설계하는 순간 시작된다.

위 차이를 이해하는 것과 이해하는 못한 상황의 격차는 앞으로 훨씬 더 벌어질 것이다.

References:

4/10/2026

모델이 읽는 쓰레기 줄이기

요즘 팀내에서 토큰 부족 현상이 자주 발생한다. 

Budget을 무한정 투입할 수 없는 상황이라 여러 고민을 하던 중, Github에 꽤 괜찮은 Repo가 있는 것을 발견했다. 팀에 내용을 공유하고 여기에 정리해본다.

A close up of a thermometer and a hose
Photo by camera obscura on Unsplash

AI 코딩 도구를 처음에 쓸땐 대부분 감탄한다. 코드를 읽고, 테스트를 수행하고, 수정안을 내놓는 속도가 생각보다 빠르다. 사람보다 빠르다는 말이 과장이 아닐 때도 있다.

그러나 오랫동안 붙잡고 있으면 문제가 나타난다. 대화가 길어질수록 에이전트가 점점 이상해진다. 방금 전까지 이해하던 문맥을 놓치고, 이미 확인한 내용을 다시 확인하고, 중요하지 않은 로그에 매달린다. 모델이 멍청해졌다기보다는 모델이 읽는 환경이 나빠졌다고 봐야한다.

RTK는 이런 문제를 해소하기 위해 등장했다. 공식 설명은 단순하다.

CLI 출력이 LLM의 context window에 들어가기전에 필터링하고 압축하는 CLI Proxy이다.

즉, 모델을 바꾸는 도구가 아니라, 모델에게 들어가는 입력의 형태를 바꾸는 도구다. CLI noise를 줄여 더 나은 reasoning, 더 긴 세션, 더 낮은 비용을 만들기 위함히다.

우리는 종종 더 큰 모델, 더 긴 컨텍스트, 더 좋은 에이전트를 원한다. 하지만 실제 사용에서 문제가 되는 것은 모델의 지능이 아니라 입력의 질이다. 지나치게 장황한 git diff, 쓸모없는 pass log로 가득한 cargo test, 사람이 터미널에서 볼 때는 무해하지만, 모델에게는 비용과 혼란만 남기는 출력들... RTK는 이 문제를 아래와 같이 접근한다.

모델이 읽는 터미널은 아직도 인간용으로 설계되어 있다.

공식 사이트를 보면 숫자가 매력적이다. 평균 89%의 노이즈 제거, 3배 더 긴 세션을 언급한다. 대체로 큰 폭의 출력 압축을 지향하지만 수치는 커맨드와 환경에 따라 다르다고 인지해야 한다.


RTK의 구조는 생각보다 단순하다. Github 아키텍처 문서를 보면 이 도구는,

  1. 특정 커맨드를 감지하고
  2. 원래 커맨드를 실행한 뒤
  3. stdout/stderr를 캡쳐하고
  4. 커맨드 종류에 맞는 필터를 적용하고
  5. 더 짧은 형태로 다시 출력한다.

즉, RTK는 커맨드별 규칙 기반 압축기이다. 단순해서 신뢰가 간다. 모델이 요약하는 구조가 아니라, 개발 도구의 출력 형식을 사람이 이해 가능한 규칙으로 재구성하는 쪽에 가깝기 때문이다.

그렇다고 RTK를 단순한 "토큰 절약기"로만 보는 것은 이 도구의 확장성 관점에서 아깝다. RTK는 LLM용 인터페이스 레이어라고 볼 수 있다.

우리가 사용하는 CLI는 원래 인간을 위한 인터페이스다. 행 단위로 길게 출력하고, 강조를 위해 반복하고, 상태를 친절하게 설명하고, 때때로 인테리어 장식도 넣는다. 그중 사람은 필요한 것만 골라서 본다.

반면 대부분 LLM의 경우는 사람처럼 골라보지 못한다. 읽을 수 있는 것은 읽고, 읽은 것은 비용이 되고, 비용은 곧 컨텍스트 오염이 된다. RTK는 이 오래된 CLI를 LLM 친화적으로 번역한다. 같은 사실을 더 짧고 구조적으로 표현하는 것이다.

이 아이디어는 생각보다 큰 의미를 가진다. AI 시대에 경쟁력이 모델 그 자체에서만 생기는 것이 아니라, 모델이 무엇을 어떤 형태로 읽게 하느냐에서 생길 수 있단느 점을 보여주기 때문이다.

물론, 모든 컨텍스트 문제의 해결사는 아니다. Shell 출력이라는 오염원 하나를 잘라내는 도구로 봐야 한다. 그러나 이것만 해도 꽤 큰 오염원 제거이다. 현실의 생산성 도구는 대체로 이렇게 부분적인 문제를 해결해나가기 때문이다.

이제까지 살펴본 바로는 이 프로젝트는 "더 똑똑한 모델"을 포커싱하는 것이 아니라, "더 적절한 입력"을 문제의 중심에 놓고 있다. 지금까지 AI 도구 시장은 주로 모델 교체를 경쟁처럼 진행되었다. GPT가 좋냐, Claude가 좋냐, Gemini가 좋냐 등... 그런데 현장에서는 종종 더 하위 레이어가 중요하다. 파일을 어떻게 읽히게 할 것인가, 테스트 결과는 어디까지 보여줄 것인가, diff를 어떤 단위로 잘라줄 것인가, 이런 문제들은 모델의 IQ보다 입구의 형식과 더 가깝다. RTK는 이 문제에 접근해서 풀어냈다.

이미 있는 모델이 쓸데없는 것을 덜 읽게 만든다.

이것은 화려하진 않지만 대단히 실용적이다.

그런데, 불편한 점도 존재한다. 압축은 trade-off다. 출력이 짧아진다는 것은 토큰 낭비를 덜한다는 점에서 좋아보이지만, 어떤 상황에서는 정보 손실이 될 수 있다. 상황에 따른 호불호가 있다고 생각된다. 그래서 RTK에서는 언제 압축하고 언제 원본으로 돌아갈지를 사용자가 통제할 수 있게 하였다.

이 프로젝트는 단순한 유틸리티로 볼 수도 있다. 하지만 AI Native 개발 환경 관점에서 보면 느낌이 다르다.

모델은 두뇌이고, RTK와 같은 도구는 감각을 정리하는 장치다.

두뇌를 키우는 일만큼, 들어오는 감각을 정제하는 일도 중요하다는 것을 이 도구가 보여주기 때문이다.

결국 RTK가 던지는 질문은 단순하다.

정말 필요한 것은 더 큰 모델일까? 아니면 더 깨끗한 입력일까?

아마도 답은 둘 다일 것이다. 그러나 현장에서는 두 번째가 더 중요하다. 더 큰 모델은 비싸고, 느리고, 언제나 접근 가능하지 않기 때문이다. 반면 입력을 정리하는 일은 상대적으로 싸고, 빠르고, 바로 적용이 가능하다. 이 작은 도구는 거대한 AI 혁신처럼 보이지는 않지만, 실제 사용 경험의 병목을 직접 건드린다.

"LLM이 읽는 모든 것을 더 많이 넣자!"는 방향이 아니라, "LLM이 읽을 가치가 없는 것을 빼자!"는 방향을 선택한다.

이 프로젝트가 의미 있다고 보는 이유는, 문제를 정확히 문제로 본다는 데 있다. AI 코딩의 병목은 모델안에만 있지 않다. 종종 모델 바깥, 터미널의 지저분한 출력과 도구 체인에 있을 수 있다.

즉, "AI가 일하는 환경을 인간 중심 인터페이스에서 기계 중심 인터페이스로 번역하려는 시도다."

나는 이런 종류의 시도가 앞으로 더 많아질 것이라고 본다. 모델이 좋아질수록, 오히려 모델 앞단의 정제 레이어가 더 중요해질 가능성이 크기 때문이다.

지금 이 모델은, 무엇을 읽고 있는가?


References:

  1. https://github.com/rtk-ai/rtk
  2. https://www.rtk-ai.app/

Unlearning - 배운 것 중 필요없는 것을 버리는 능력

If you use this image, we’d appreciate a link back to our website www.quotecatalog.com.
Photo by Thought Catalog on Unsplash

우리는 그동안 지식, 경험, 확신을 계속 쌓아왔다. 더 많이 알고, 더 정교한 프레임을 갖고, 더 많은 경험을 쌓는 사람이 결국 더 멀리 간다고 생각했다. 

실제로 그동안 역사에서 그것은 맞는 말이었다. 산업화 시대에도 그랬고, 디지털 전환 초반에도 그랬다. 문제는 지금이다. 지금은 많이 아는 사람이 아니라, 무엇을 계속 붙잡고 있는지 스스로 의심할 수 있는 사람이 더 멀리 간다. 새로운 것을 배우는 능력보다, 한때 나를 성공시켰던 방식을 내려놓는 능력이 더 중요해진 시대다.

경영학에서 이 문제를 오래전부터 다뤄온 개념이 바로 organizational unlearning이다. 고전적으로는 Hedberg가 조직이 학습할 뿐 아니라 “기존의 이해와 방식을 벗어나는 과정”도 필요하다고 보았고, 이후 연구들은 이를 조직 변화의 핵심 주제로 확장해 왔다.

대부분 unlearning을 “잊는 것” 정도로 이해한다. 하지만 연구자들은 대체로 그렇게 보지 않는다. 최근 리뷰들은 unlearning을 단순한 망각이 아니라, 더 이상 적합하지 않은 지식/루틴/기억 구조를 의도적으로 약화시키거나 버리는 과정으로 정리한다.

이 차이는 생각보다 중요하다. 그냥 시간이 흘러서 잊어버리는 것은 forgetting에 가깝다. 하지만 “이 방식은 더 이상 맞지 않는다”는 판단 아래 기존의 신념, 관행, 규칙, 평가기준을 흔들고 재배치하는 것은 unlearning에 가깝다. 

다시 말해 unlearning은 기억의 자연 소멸이 아니라, 판단 체계의 의도적 수정이다. 그래서 이 개념은 개인보다도 조직 변화, 혁신, 전략 전환, 리더십, 팀 실험과 더 자주 연결된다.

이 지점에서 Chris Argyris의 double-loop learning은 여전히 유효하다. Argyris는 조직이 오류를 수정하는 데에도 두 단계가 있다고 봤다.

하나는 기존 목표와 규칙을 그대로 둔 채 그 안에서 오차를 고치는 방식이고, 다른 하나는 아예 그 목표와 규칙 자체, 즉 “governing variables”를 다시 묻는 방식이고, 이것이 double-loop learning이다.

이 개념은 unlearning과 동일하지는 않지만, 실제 조직에서 unlearning이 일어나는 방식과 깊게 닿아 있다. 왜냐하면 기존의 운영 변수와 기준을 바꾸지 않으면, 새로운 학습은 대부분 낡은 프레임 안에 흡수되기 때문이다. 결국 무언가를 새로 배우는 일보다 먼저 필요한 것은, 지금의 기준이 여전히 맞는지를 묻는 일이다.

그래서 unlearning은 학습의 반대말이 아니다. 정확하게 말하면, 제대로 배우기 위해 필요한 해체 과정에 가깝다. 조직은 흔히 새로운 시스템을 도입하고, 새로운 도구를 교육하고, 새로운 KPI를 붙이면 변화가 일어난다고 생각한다. 하지만 현실에서는 새 제도가 들어와도 사람들은 예전 방식으로 해석하고 예전 방식으로 사용한다.

그래서 AI를 도입해도 구조는 쉽게 바뀌지 않는다. 승인 체계는 그대로 남고, 보고 방식도 달라지지 않는다. 클라우드로 옮겨도 온프레미스 시절의 의사결정 속도와 통제 습관이 그대로면 혁신은 지연된다. 애자일을 선언해도 실패를 허용하지 않는 평가 체계가 유지되면 팀은 더 자주 회의할 뿐 덜 실험하지는 않는다. 최근 연구들이 unlearning을 개인, 팀, 조직의 여러 수준에서 동시에 봐야 한다고 강조하는 이유가 여기에 있다.

이제 왜 지금 unlearning이 중요한지 생각해볼 필요가 있다.

첫째는 환경 변화의 속도 때문이다. 과거에는 한번 익힌 지식의 유효기간이 꽤 길었다. 제품 사이클도 길었고, 조직 구조도 비교적 천천히 변했다. 하지만 지금은 시장, 기술, 규제, 고객 기대가 동시에 빠르게 바뀐다.

최근 리뷰들은 조직 기억이 개인 기억, 팀 기억, 루틴과 관행, 디지털 저장소까지 여러 레이어위에 저장된다고 설명하는데, 문제는 이 기억 구조가 환경 변화보다 느리게 움직인다는 점이다. 조직은 늘 이미 지나간 현실에 맞춰 최적화되어 있기 쉽다. 이럴 때 필요한 것은 추가 학습보다 현재를 더 이상 설명하지 못하는 기억 구조를 약화시키는 일이다.

둘째는 AI 시대의 아이러니 때문이다. 많은 사람이 AI 시대를 “배움이 쉬워진 시대”로 말한다. 분명 맞는 말이다. 정보 접근 비용은 낮아졌고, 코드 작성, 문서 초안, 자료 조사, 번역, 요약 같은 지식노동의 진입장벽은 빠르게 내려가고 있다.

그래서 무엇을 새로 배우느냐보다 어떤 프레임으로 질문하느냐가 더 중요해졌다. 기존 방식대로 질문하면 기존 방식대로 답을 얻는다. 기존 조직 논리 안에서 AI를 배치하면 AI는 혁신 엔진이 아니라 자동화된 보조 인력으로 축소된다. 이때 필요한 것은 “AI를 배우자”라는 구호가 아니라, “우리가 일을 정의하는 방식부터 다시 볼 수 있는가”라는 질문이다. 이것은 기술 도입의 문제가 아니라 unlearning의 문제다.

unlearning이 어려운 이유는 아래와 같다.

첫째, 사람은 자신이 틀렸다는 사실보다 자신이 틀릴 수 있다는 사실을 견디기 어려워한다. 오래 써온 개념, 익숙한 루틴, 성과를 냈던 프레임은 단순한 지식이 아니라 정체성의 일부가 된다. 그래서 unlearning은 정보 업데이트보다 훨씬 불편한 경험이다.

둘째, 조직 차원에서는 성과평가와 보고체계가 이를 더 어렵게 만든다. 조직은 예측 가능성과 반복 가능성을 좋아한다. 반면 unlearning은 대체로 불확실성과 실험, 일시적 혼란을 수반한다.

셋째, 성공 경험이 강할수록 더 버리기 어렵다. 실패한 방식은 쉽게 버릴 수 있지만, 성공한 방식은 마지막까지 남는다. 바로 이 때문에 많은 기업이 위기 때보다 호황기 말기에 더 취약하다.

unlearning은 종종 도전(challenge)으로 시작된다. 여기서 challenge는 단순한 반항이 아니다. 지금의 질서, 지금의 설명, 지금의 성공 공식을 다시 질문하는 과정이다. 무엇이 당연한가를 묻는 순간, 조직은 비로소 현재를 현재의 언어로 보기 시작한다. 어떤 사람의 생각이 바뀌는 것만으로는 unlearning이 완성되지 않는다. 기준, 프로세스, 루틴, 자원 배분, 승인 구조가 함께 바뀌어야 한다.

그렇다면 실무에서 unlearning은 어떻게 일어나는가? 나는 이것을 세 단계로 설명하는 편이 가장 현실적이라고 본다.

첫 번째는 인식이다. 지금의 문제가 실행력 부족인지, 아니면 전제 자체가 낡았는지 구분해야 한다. 대부분의 조직은 낡은 프레임의 문제를 실행의 문제로 오해한다. 고객 반응이 달라졌는데 메시지의 빈도를 높이거나, 제품 구조가 바뀌었는데 보고 횟수를 늘리거나, 전략의 전환이 필요한데 예전 KPI를 더 엄격히 적용한다. 이 단계에서 필요한 질문은 단순하다. 

“우리는 무엇을 너무 당연하게 여기고 있는가?”

두 번째는 분리다. 낡은 지식이 사람의 능력 부족 때문인지, 루틴 때문인지, 제도 때문인지 떼어서 봐야 한다. 조직 기억은 개인 기억만이 아니라 팀 기억, 루틴과 관행, 디지털 저장소에 분산되어 있다. 그래서 unlearning은 교육만으로 해결되지 않는다. 사람은 바뀌었는데 회의체가 안 바뀌면 예전 방식이 돌아오고, 프로세스가 바뀌었는데 데이터 정의가 안 바뀌면 같은 판단이 반복된다. 시스템 차원에서 무엇이 기존 질서를 지탱하는지 분리해 보지 않으면, 조직은 늘 “새로운 언어로 옛날 일”을 하게 된다.

세 번째는 대체다. 버리는 것만으로는 조직이 움직이지 않는다. 기존 신념과 관행을 제거한 자리에 새로운 해석과 루틴이 들어와야 한다. 새로운 제도가 실제로 반복되고 저장되는 구조를 만드는 일이다. 결국 조직은 기억하는 방식대로 움직이기 때문이다.

unlearning을 정말 쓰고 싶다면, 막연히 “과거를 버려야 한다”는 선언이 아니라 무엇이 어떻게 약화되었는지?, 무엇이 대체되었는지?, 그 변화가 실제 루틴과 의사결정에 어떻게 남았는지를 보여줘야 한다. 그렇지 않으면 unlearning은 그냥 멋있는 단어에 그친다.

실무에서 unlearning을 판단하는 가장 현실적인 기준은 이것이다.

  • 새로운 도구를 도입했는가? 가 아니라, 옛 판단 기준이 약해졌는가?
  • 새로운 조직도를 만들었는가? 가 아니라, 예전 승인 구조가 실제로 덜 중요해졌는가?
  • AI를 붙였는가? 가 아니라, 사람이 직접 해야 한다고 믿었던 일의 경계가 다시 그어졌는가?
  • 데이터를 쌓았는가? 가 아니라, 직관이 아니라 실험으로 결론 내리는 비율이 높아졌는가?

이 질문들에 “그렇다”고 답할 수 있을 때 비로소 unlearning은 시작된 것이다.

그래서 나는 unlearning을 혁신의 부속 개념으로 보지 않는다. 오히려 혁신의 앞단에 놓인 조건이라고 본다. 많은 조직이 transformation을 말하지만 실제로는 기존 운영 모델을 조금 더 디지털화하는 데 그친다.

이유는 단순하다. 학습은 했지만 unlearning은 하지 않았기 때문이다. 기존의 권한 구조, 성공 공식, 리스크 정의, 고객 이해 방식이 그대로면 혁신은 반드시 기존 질서의 범위 안으로 흡수된다. 결국 “새로운 것을 받아들일 준비”보다 더 중요한 것은 “기존 것을 의심할 준비”다. unlearning은 개인의 태도 변화로 끝나지 않고, 전략적 유연성, 혁신, 조직 성과와 연결될 가능성이 있지만, 그 효과는 언제나 맥락과 구조를 탄다.

결국 unlearning은 많이 배운 사람에게 더 어려운 일이다. 많이 아는 사람은 더 많은 설명을 가지고 있고, 더 많은 성공 경험을 가지고 있으며, 더 많은 정당화를 할 수 있다. 그렇기에 배움의 총량이 많은 사람이 반드시 변화에 강한 것은 아니다. 때로는 반대다. 진짜 유연한 사람은 많이 아는 사람이 아니라, 자신의 지식이 언제 낡아지는지 감지할 수 있는 사람이다. 조직도 마찬가지다. 더 많은 시스템을 가진 조직이 강한 것이 아니라, 그 시스템을 언제 내려놓아야 하는지 아는 조직이 강하다.

지금 시대에 learning은 기본 역량이 되었다. 누구나 배울 수 있고, 도구도 많고, 접근도 빠르다. 차이를 만드는 것은 그다음이다. 무엇을 더 추가하느냐보다, 무엇을 계속 들고 가지 않느냐가 더 중요해졌다. 그래서 앞으로의 경쟁력은 지식의 축적량만으로 설명되지 않을 것이다. 본 글에서 하고 싶은 이야기는 아래의 문장으로 정리된다.

"우리는 계속 배우고 있다. 문제는, 무엇을 아직도 버리지 못하고 있는가다." 


Refercences:

  • Bo Hedberg, How Organizations Learn and Unlearn (1981). (Semantic Scholar)
  • Chris Argyris, Double-Loop Learning in Organizations (1977). (Antonie van Nistelrooij)
  • Adrian Klammer et al., Organizational unlearning as a process: What we know, what we don’t know, what we should know (2024). (ResearchGate)
  • Samuele Maccioni et al., Navigating the unlearning landscape: an organizational unlearning taxonomy and an outcome-centric model (2024). (Emerald)
  • Annette Kluge, Recent findings on organizational unlearning and intentional forgetting research (2019–2022) (2023). (Frontiers)
  • Adrian Klammer & Stefan Gueldenberg, Unlearning and forgetting in organizations: a systematic review of literature (2019). (Emerald)
  • John Howells & Joachim Scholderer, Forget unlearning? (2016). (Sage Journals)

4/06/2026

gstack을 Antigravity로 포팅


AI 코딩 도구를 쓰다 보면 비슷한 순간이 온다.

  1. 처음에는 “정말 똑똑하네”에서 시작한다.
  2. 그다음에는 “이걸 어떻게 더 잘 시킬까?”로 넘어간다.
  3. 그리고 조금 더 쓰다 보면 결국 이런 고민을 하게 된다.

이걸 팀처럼 일하게 만들 수는 없을까?

내가 gstack에 관심을 가진 이유도 여기에 있었다.

gstack은 스스로를 단순한 스킬 모음이 아니라, Claude Code를 하나의 가상 엔지니어링 팀처럼 움직이게 만드는 방식으로 설명한다. 

CEO, 엔지니어링 매니저, 디자이너, 리뷰어, QA 리드, 보안 담당, 릴리즈 엔지니어 같은 역할이 나뉘어 있고, 전체 흐름이 Think → Plan → Build → Review → Test → Ship → Reflect로 설계되어 있다. 

즉, 핵심은 프롬프트 몇 개가 아니라 역할 분리와 작업 순서에 있다.

요즘 AI 도구들은 대부분 “잘 대답하는가?”에 초점이 맞춰져 있다. 그런데 gstack은 한 걸음 더 들어가서 “어떤 순서로 일하게 만들 것인가”를 다룬다. 

  1. `/office-hours`로 문제를 다시 정의하고, 
  2. `/plan-ceo-review`와 `/plan-eng-review`로 범위와 구조를 다듬고, 
  3. `/review`, `/qa`, `/ship`으로 마무리하는 흐름은 실제 팀이 일하는 방식과 꽤 닮아 있다. 
그래서 gstack을 처음 봤을 때 든 생각은 신기하다보다 이건 실무에 더 가깝다는 쪽이었다.

그런데 여기서 다음 질문이 생겼다.

좋은 건 Claude Code 자체일까, 아니면 gstack의 워크플로우일까?

gstack은 Claude Code 중심으로 설계돼 있다. 

설치 구조도 Claude 체계를 전제로 하고 있고, 브라우저 자동화 역시 자체 browse 흐름을 기준으로 설명한다. 

ARCHITECTURE 문서에서는 persistent browser와 long-lived Chromium daemon을 유지해서 첫 호출 이후에는 빠르게 재사용하고, 세션과 탭 상태도 이어가는 방식이라고 설명한다. 

즉, 원본 gstack은 단순한 명령어 모음이 아니라 브라우저 기반 검증과 리뷰까지 포함한 일종의 소프트웨어 팩토리에 가깝다.

그래서 Antigravity로의 포팅은 이름만 바꾸는 작업이 될 수 없었다. 그냥 복사해서 붙여넣는다고 되는 구조가 아니었기 때문이다.

gstack의 핵심은 명령어 목록 그 자체가 아니라, 그 명령들이 어던 런타임 위에서 어떤 철학으로 연결되는가에 있다.

결국 이 작업은 포팅이라기보다 번역에 가까웠다. 원본의 철학과 흐름을 이해한 뒤, 그것을 Antigravity의 문법으로 다시 써야 했기 때문이다.

gstack-antigravity는 바로 이 관점에서 시작되었다. 물론 내가 antigravity를 자주 사용하는 이유도 있었다.

내가 사용하기 위해서는 Antigravity 환경에 맞춘 네이티브 포팅이 필요했고, 그 과정에서 Thin Router Architecture, Native Browser Integration, Cross-Platform Parity를 고민하게 됐다. 

즉, 원본을 그대로 흉내 내는 포크가 아니라, 원본 워크플로우를 Antigravity 쪽에서 오래 버틸 수 있게 다시 설계한 포팅이라고 보는 편이 맞다.

또 하나는 토큰 문제였다.

AI 워크플로우를 오래 쓰다 보면 언젠가는 비슷한 문제를 겪게 된다.

처음에는 잘 되는데, 문맥이 길어질수록 점점 느려지고, 작업이 커질수록 흐름이 흐트러진다. 특히 역할과 규칙이 많아질수록, 매번 모든 설명을 통째로 들고 다니는 방식은 금방 무거워진다. 

gstack-antigravity는 이 문제를 해결하기 위해, 가벼운 규칙 파일이 먼저 라우터처럼 동작하고 실제 워크플로우가 호출될 때만 필요한 내용을 읽어오는 방향을 택했다.

모든 걸 항상 들고 있는 구조가 아니라, 필요한 순간에 필요한 것만 가져오는 구조를 지향하는 셈이다.

이런 종류의 포팅이 실패하는 가장 흔한 이유는 원본 시스템의 방식을 너무 고집해서, 새 환경이 이미 잘하는 것을 못 쓰는 경우다. 

그래서 gstack-antigravity는 원본처럼 별도의 브라우저 체계를 억지로 유지하기보다 Antigravity가 제공하는 네이티브 브라우저 도구를 우선 활용하는 방식으로 정리했다.

나는 이 방향이 꽤 중요하다고 생각한다. 좋은 포팅은 원본을 똑같이 복제하는 것이 아니라, 원본의 철학을 유지한 채 새 환경이 잘하는 방식을 받아들이는 일에 더 가깝기 때문이다.

그리고 이 포팅은 antigravity-skills와 함께 쓰면 더 효율적이다. 실제 작업할 때는 큰 흐름을 잡아주는 운영체계와 세부 작업을 도와주는 스킬셋을 나눠 쓰는 편이 훨씬 효율적이다.

gstack-antigravity가 생각-계획-구현-리뷰-QA-배포 같은 전체 흐름을 잡아주는 쪽이라면, antigravity-skills는 브레인스토밍이나 계획 작성 같은 작업 단위 스킬을 보강하는 쪽에 가깝다.

개인적으로 이 조합이 괜찮다고 느껴지는 이유는 현실의 작업 방식과도 잘 맞기 때문이다.

실제 일은 처음부터 끝까지 한 가지 모드로만 흐르지 않는다. 

  • 어떤 날은 아이디어를 넓게 보는 시간이 필요하고, 
  • 어떤 날은 빠르게 계획을 해야 하며, 
  • 어떤 날은 리뷰와 QA가 더 중요하다. 

이럴 때 gstack-antigravity가 전체 뼈대를 잡아주고, antigravity-skills가 필요한 순간에 세부 스킬을 보강해주면 흐름이 훨씬 부드러워진다. 

예를 들어 새로운 기능을 시작할 때는 먼저 @brainstorming으로 문제를 살펴보고, 그다음 gstack 스타일의 계획 흐름으로 구조를 잡고, 구현 이후에는 리뷰와 QA로 마무리하는 식이다. 

즉, 이 둘은 경쟁 관계라기보다 운영체계와 도구 상자라고 표현하는 편이 더 맞다.

AI 도구를 오래 써보면 결국 필요한 건 “더 똑똑한 답변”만이 아니다. 오히려 더 절실한 건 흐트러지지 않는 작업 흐름, 길어져도 무너지지 않는 문맥 관리, 실제로 계속 쓸 수 있는 운영 방식이다. 

gstack-antigravity는 원본 gstack의 핵심인 역할 분리, 스프린트형 흐름, 작업 철학을 유지하면서, 그것을 Antigravity 환경에 맞게 다시 설계한 포팅이다. 

이 과정에서 얇은 라우팅 구조를 통한 문맥 경량화, Antigravity 네이티브 브라우저 도구 활용, 크로스 플랫폼 대응을 함께 고민했다. 

여기에 antigravity-skills 같은 실전 스킬 저장소를 함께 붙이면, 전체 흐름과 세부 작업을 나눠서 다루는 좀 더 현실적인 작업 방식이 만들어진다.

혹시, 써보고 싶은신 분들은 아래를 참고하세요.

https://www.npmjs.com/package/@runchr/gstack-antigravity

다음 글에서는 paperclipai + opencode 같은 조합으로 여러 Agent를 회사 조직처럼 묶어서 운영하는 방법에 대해 정리해보려고 합니다.

3/29/2026

Mitchell Hashimoto의 「My AI Adoption Journey」를 읽고

본 글은 Mitchell Hashimoto의 을 읽고 정리한 글이다.

AI를 둘러싼 이야기는 대체로 두 갈래로 흐른다. 하나는 모든 것이 곧 AI로 대체될 것이라는 과장된 낙관론이고, 다른 하나는 아직은 실무에서 믿고 쓰기 어렵다는 냉소다. 

그런데 실제로 생산성을 만들어내는 사람들의 이야기는 중간 어딘가에 있다. Mitchell Hashimoto가 2026년 2월에 쓴 "My AI Adoption Journey" 도 그런 글이다. 

이 글은 특정 모델을 찬양하는 글도 아니고, 반대로 AI를 무의미한 유행으로 치부하는 글도 아니다. 그는 자신이 AI를 어떤 순서로 받아들였고, 어디에서 실망했고, 어느 시점부터 실질적인 가치를 느꼈는지를 여섯 단계로 정리한다.

Hashimoto는 새로운 도구를 도입할 때 대체로 세 시기를 거친다고 말한다. 

처음에는 비효율의 시기가 있고, 그다음에는 그럭저럭 쓸 만한 단계가 오고, 마지막에는 워크플로우 자체를 바꾸는 수준의 발견에 도달한다는 것이다. 

AI도 예외가 아니었다. 이미 손에 익은 방식이 있는데 새로운 도구를 배우는 일은 그 자체로 비용이 들고, 그래서 대개 사람은 초반의 불편함을 견디지 못한 채 포기한다. 그럼에도 그는 그 비효율의 시기를 통과해야만 진짜 판단이 가능하다고 얘기한다. 이것이 중요한 이유는, AI 도입을 단순히 “좋으냐 나쁘냐”로 나누지 않고, 도구 채택의 자연스러운 학습 곡선으로 보기 때문이다.

그의 첫 번째 결론은 의외로 단호하다. 의미 있는 코딩 작업을 웹 챗봇 인터페이스에서 하려는 시도를 그만두라는 것이다. ChatGPT나 Gemini 같은 챗 인터페이스는 여전히 가치가 있지만, 복잡한 코드 작업에서는 한계가 분명하다고 얘기한다. 

특히 기존 코드베이스처럼 맥락이 많은 환경에서는 결과가 자주 어긋나고, 사람이 코드와 로그를 복사해 붙여넣으며 계속 오류를 바로잡아야 하므로 오히려 비효율적이라는 판단이다. 그가 본격적으로 가치를 느낀 지점은 챗봇이 아니라 에이전트였다. 그가 말하는 에이전트는 단순히 대화하는 모델이 아니라, 파일을 읽고, 프로그램을 실행하고, HTTP 요청을 보내며, 이런 행동을 반복 루프 안에서 수행할 수 있는 형태의 도구다. 즉, “답해주는 AI”보다 “일할 수 있는 AI”가 필요하다는 이야기다.

두 번째 단계에서 그는 AI에게 자신의 일을 맡기기 전에 먼저 아주 불편한 실험을 한다. 사람이 직접 한 작업을, 에이전트만으로 다시 재현해보는 것이다. 같은 일을 두 번 하는 셈이니 당연히 비효율적이다. 실제로 그는 이 과정을 고통스럽다고 표현한다. 하지만 이 반복 속에서 중요한 감각이 생겼다고 말한다. 

하나의 거대한 세션으로 모든 것을 해결하려고 하면 실패 확률이 높고, 작업은 명확하고 실행 가능한 작은 단위로 나눠야 한다는 점이다. 또 요청이 모호하다면 계획 단계와 실행 단계를 분리해야 하며, 에이전트가 자기 결과를 검증할 수 있는 방법을 주면 스스로 실수를 고치고 회귀를 줄일 가능성이 높아진다는 점도 확인한다. 

결국 여기서 얻은 가장 큰 성과는 “AI가 무엇을 잘하는가”보다 “AI에게 무엇을 맡기면 안 되는가”를 배운 데 있었다. 이 경계를 아는 것만으로도 시간 낭비를 크게 줄일 수 있기 때문이다.

대부분 많은 사람들이 지금도 AI 생산성을 모델의 지능에서만 찾으려 하고 있다. Hashimoto의 경험은 조금 다르다. 생산성은 더 똑똑한 모델에서만 오지 않는다. 오히려 실패할 일을 애초에 던지지 않는 판단, 모호한 일을 계획과 실행으로 분리하는 습관, 검증 수단을 함께 주는 방식 같은 운영 감각에서 더 많이 나온다. 즉, AI를 잘 쓰는 능력은 “좋은 질문을 던지는 능력”만이 아니라 “실패할 조건을 미리 제거하는 능력”에 가깝다. 

그는 이 단계에서 이미 에이전트를 워크플로우 안에 넣을 수 있을 정도의 가치를 느꼈지만, 아직 자신보다 확실히 빠르다고 생각하지는 않았다고 얘기한다.

세 번째 단계는 하루의 끝을 활용하는 방식이다. 그는 근무 마지막 30분 정도를 따로 확보해 하나 이상의 에이전트를 실행한다. 사람의 집중력은 하루 후반부로 갈수록 떨어지고, 이때 억지로 깊이 있는 작업을 계속하기보다 에이전트를 돌려 다음 날의 준비물을 만들어두는 편이 낫다고 본 것이다. 

여기에는 몇 가지 유형이 있다. 특정 언어나 라이선스 조건에 맞는 라이브러리를 조사해 장단점과 개발 현황, 커뮤니티 반응까지 정리하게 하는 딥 리서치, 아직 모양이 잡히지 않은 아이디어를 병렬적으로 탐색하는 시도, 그리고 GitHub 이슈나 PR을 분류하고 검토 보고서를 만드는 일이 대표적이다. 

그는 에이전트를 밤새 무한 루프로 돌리는 극단적인 방식까지 간 것은 아니라고 분명히 얘기한다. 대부분의 작업은 30분 이내에 끝났다. 그러나 그 정도만으로도 다음 날 아침 더 빨리 일에 들어갈 수 있는 “웜 스타트”가 만들어졌다고 평가한다.

우리는 흔히 AI가 사람보다 즉시 빠르고 정확해야만 유용하다고 생각한다. 하지만 실제 업무에서는 사람이 일하지 못하는 시간에 다음 작업의 맥락과 재료를 준비해두는 것만으로도 충분히 큰 가치가 생긴다. 

AI는 사람과 경쟁하는 속도 도구가 아니라, 사람의 비가동 시간을 생산적인 준비 시간으로 바꾸는 장치가 될 수 있다는 뜻이다. 여기서 중요한 것은 완전 자동화가 아니라, 사람의 리듬에 맞춘 보조다. Hashimoto의 경험은 AI 활용이 반드시 실시간 협업만을 의미하지 않으며, 비동기적으로도 충분히 강력할 수 있음을 보여준다.

네 번째 단계에서 그는 조금 더 과감해진다. 이제는 에이전트가 거의 틀리지 않을 것 같은 일을 골라, 백그라운드에서 실제로 맡기기 시작한다. 전날 밤 에이전트가 분류해둔 이슈나 작업 목록을 보고, 그중 성공 확률이 높은 것만 골라 하나씩 돌려두고, 자신은 그동안 다른 깊은 작업을 한다. 

여기서 그가 강조하는 원칙 하나는 에이전트의 데스크톱 알림을 꺼야 한다는 것이다. 이유는 단순하다. 컨텍스트 스위칭 비용이 크기 때문이다. 인간이 언제 에이전트를 통제해야지, 에이전트가 사람의 집중을 끊어서는 안 된다. 

자연스러운 휴식 구간이나 전환 지점에서만 에이전트를 확인하고 다시 자기 일로 돌아가야 한다는 것이다. 이 원칙은 AI 도입의 문제를 기술 문제가 아니라 주의력 관리 문제로도 바라보게 만든다. 

그는 이 단계가 AI가 기술 형성을 해칠 수 있다는 우려와도 일정한 균형을 만든다고 본다. 덜 중요하거나 비교적 확실한 작업은 에이전트에게 맡기되, 자신이 계속 성장하고 싶은 영역의 작업은 여전히 수작업으로 유지하는 방식이다. 

이 우려는 과장된 것이 아니다. Anthropic이 2026년 1월 공개한 연구는, 새로운 Python 라이브러리를 익히는 과제에서 AI 도움을 받은 참가자들이 도움을 받지 않은 집단보다 개념 이해, 코드 읽기, 디버깅 능력에서 더 낮은 점수를 기록했다고 보고했다. 

논문 초록은 평균적으로 유의미한 효율 향상도 크지 않았으며, 특히 과제를 AI에 많이 위임할수록 학습 손실이 커졌다고 설명한다. 반면 AI를 단순 대행자가 아니라 설명과 분석 보조 도구로 쓴 참가자들은 상대적으로 더 나은 학습을 보였다는 해석도 함께 나온다. 결국 문제는 AI 사용 여부 자체가 아니라, 무엇을 위임하고 무엇을 직접 이해할 것인가에 대한 것이다.

다섯 번째 단계에서 이 글의 핵심이 나온다. 바로 “Engineer the Harness” 하네스를 설계하라는 말이다. Hashimoto는 에이전트가 처음부터 맞는 결과를 내거나, 최소한 아주 적은 수정만 필요하도록 만들수록 효율이 급격히 높아진다고 봤다. 그리고 이를 위한 가장 확실한 방법은, 에이전트가 틀렸을 때 빠르고 정확하게 틀렸음을 알려주는 좋은 도구를 주는 것이라고 말한다. 

그는 이 접근을 “하네스 엔지니어링”이라 부른다. 뜻은 명확하다. 에이전트가 어떤 실수를 했다면, 그 실수를 다시는 반복하지 못하도록 환경과 도구를 설계하는 것이다. 이 발상이 중요한 이유는 AI 활용의 중심을 프롬프트에서 시스템 설계로 이동시키기 때문이다. 반복되는 실수를 사람의 인내로 감당하는 대신, 작업 환경의 규칙과 검증 장치로 흡수하는 것이다.

그는 하네스 엔지니어링을 두 가지 형태로 설명한다. 

첫째는 더 나은 암묵적 프롬프팅이다. 예를 들어 AGENTS.md 같은 파일에, 에이전트가 자주 잘못 사용하는 명령어, 자주 엉뚱하게 찾는 API, 특정 서브시스템에서 먼저 확인해야 하는 파일, 플랫폼별 검증 방법 같은 맥락 정보를 짧고 구체적으로 적어두는 방식이다. 

Hashimoto는 Ghostty 저장소의 AGENTS.md를 사례로 제시하며, 그 파일의 각 줄이 실제로 나쁜 에이전트 행동 하나를 겨냥해 추가된 것이고 결과적으로 문제를 거의 해결했다고 말한다. 

둘째는 실제 도구다. 스크린샷을 찍는 스크립트, 일부 테스트만 빠르게 실행하는 스크립트, 결과를 필터링해 이상 여부를 바로 확인하는 도구 등이 여기에 속한다. 

핵심은 에이전트가 결과를 스스로 검증할 수 있어야 한다는 점이다. 사람의 눈으로만 확인해야 하는 작업은 결국 병목이 된다. 반대로 검증이 자동화되면, AI는 “시도하는 도구”에서 “자기 오류를 교정하는 시스템의 일부”가 된다.

이 부분이 특히 중요한 이유는, 소프트웨어 엔지니어링의 좋은 원칙과 정확히 닿아 있기 때문이다. 

좋은 팀은 버그를 하나 고치고 끝내지 않는다. 왜 그 버그가 다시 생기지 않게 할 것인지까지 고민한다. 테스트를 추가하고, 린트 규칙을 넣고, 배포 전 체크를 강화하고, 문서와 실행 규칙을 손본다. 

Hashimoto가 말하는 하네스 엔지니어링은 사실 AI 시대에 새로 생긴 마법이 아니라, 익숙한 프로그래밍 원칙을 AI 작업에 그대로 확장한 것이다. 

에이전트가 잘못했다면 그것은 한 번의 실패가 아니라, 다음부터 시스템으로 줄일 수 있는 결함 패턴이다. 따라서 AI를 잘 쓰는 사람은 답변을 더 정교하게 유도하는 사람이라기보다, 실패를 재발 방지 가능한 구조로 바꾸는 사람에 가깝다.

여섯 번째 단계는 “항상 에이전트 하나는 돌아가고 있는 상태”를 목표로 삼는 것이다. 그는 아직 여러 에이전트를 동시에 대규모로 운영하고 싶지는 않다고 말한다. 다만 최소한 하나의 에이전트는 가능한 자주 백그라운드에서 일하고 있기를 바란다. 

에이전트가 돌아가고 있지 않을 때면, 지금 당장 에이전트가 대신 할 수 있는 일이 없는지 스스로 묻는다는 것이다. 다만 여기서도 그는 중요한 선을 긋는다. 에이전트를 돌리기 위해 억지로 일을 만드는 것이 목적은 아니다. 실제로 도움이 되는 일이 있을 때만 돌려야 한다. 그래서 이 목표를 실현하려면, 자신의 워크플로우 자체를 개선해 위임 가능한 고품질 작업이 꾸준히 나오도록 만들어야 한다고 본다. 

그는 현재 자신이 근무 시간의 대략 10~20% 정도만 이런 방식으로 효과적으로 운영하고 있다고 밝힌다. 이 수치는 AI 도입이 완성형이 아니라 계속 다듬어가는 과정임을 보여준다.

마지막으로 그는 자신이 AI 기업에서 일하지도, 투자하지도, 자문하지도 않는다고 밝힌다. 또 AI가 영원히 남을지 여부보다, 지금 자신이 무언가를 만드는 데 실제로 도움이 되는지가 더 중요하다고 말한다. 

AI 시대의 생산성 차이는 누가 더 화려한 프롬프트를 쓰느냐에서 갈리지 않는다. 진짜 차이는 누가 더 좋은 작업 환경을 설계하느냐에서 발생한다. 

챗봇에 멋진 질문을 던지는 능력은 출발점일 수 있지만, 지속적인 생산성의 원천은 아니다. 더 큰 차이는 에이전트가 일할 수 있는 문맥을 만들고, 잘못된 행동을 빠르게 잡아내고, 반복되는 실수를 규칙과 도구로 제거하며, 사람은 더 중요한 문제에 집중할 수 있도록 일의 배치를 다시 짜는 데서 생긴다. 

그런 의미에서 Hashimoto의 여정은 AI 사용 팁이라기보다, 새로운 도구를 실무에 흡수하는 엔지니어링 방법론에 가깝다. AI를 잘 쓰는 사람은 프롬프트를 다듬는 데서 멈추지 않는다. 결국 하네스를 만든다.