딥마인드

[공유] 만다라트 플래너 html 템플릿 - 목표를 9배 더 선명하게 만드는 도구

Deepmind_딥마인드 — Fri, 26 Jun 2026 14:39:41 +0900

"해야하는데..."

생각만 하는 경우가 많았습니다. 실천으로 옮기기 힘들었습니다. 실천만 해도 안되는 것들을 해결해보고 합니다.

100년에 한번 나올까 말까하는 야구선수. 오타니 쇼헤이가 사용하는 기법으로 널리 알려졌죠.

저는 오타니 쇼헤이의 만다라트 플래너를 보고 오타니가 잘 될수밖에 없었구나 하며 인정했습니다.

그런 만다라트 플래너를 직접 그리기엔 많은 수고가 필요하죠. 인쇄만 해서 쓰면 되는것이 아니냐 하실수도 있습니다.

하지만 저는 컴퓨터로 입력할 수 있어야 하고 저장, 불러오기, 인쇄/PDF저장이 되는 템플릿이 필요했습니다.

그래서 만들었습니다.

사용 방법

1. 다운로드 후 바로 열기

파일을 받으면 더블클릭만 하면 됩니다. 설치도, 회원가입도, 인터넷 연결도 필요 없습니다. 브라우저에서 바로 열립니다.

2. 정가운데 칸에 핵심 목표 적기

가장 먼저 채울 칸은 정중앙입니다. 올해, 혹은 이번 분기의 가장 큰 목표를 적습니다.

예: "이직 성공", "사이드 프로젝트 런칭", "건강한 한 해 보내기"

사실 이 한 칸을 채우는 데 제일 오래 걸렸습니다. "진짜 내가 원하는 게 뭐지?"를 스스로 묻게 되더라고요.

3. 둘레 8칸에 세부 목표 적기

핵심 목표를 이루기 위한 8가지 갈래를 적습니다. 적는 순간, 같은 색으로 표시된 바깥 8개 블록의 제목 칸에 자동으로 반영됩니다. 똑같은 내용을 두 번 입력할 필요가 없습니다.

예: 운동, 식단, 멘탈 관리, 학습, 인맥, 재무, 휴식, 정기 점검

4. 바깥 8개 블록의 나머지 64칸에 실행 항목 적기

이제부터가 진짜입니다. 각 세부 목표 아래에 "오늘 당장 할 수 있는" 구체적인 행동을 채워 넣습니다.

예: "주 3회 30분 걷기", "퇴근 후 1시간 알고리즘 풀기", "11시 전에 자기"

64칸을 다 채우고 나면, 머릿속에 흩어져 있던 막연한 다짐들이 실제로 손에 잡히는 To-do 리스트로 바뀌는 걸 느낍니다.

5. 저장하고, 나중에 다시 불러오기

다 채운 내용은 JSON 파일로 저장할 수 있습니다. 분기마다 한 번씩 다시 불러와서 점검하고 업데이트하면 됩니다. 처음부터 다시 그릴 필요가 없습니다.

6. 인쇄 또는 PDF로 저장

버튼 하나로 A4 한 장에 깔끔하게 인쇄됩니다. 책상 앞에 붙여두기 좋고, PDF로 저장해서 폰 배경화면이나 다이어리에 넣어도 됩니다. 회사 프린터처럼 컬러 인쇄가 안 되는 환경이라면 흑백 전용 버전을 따로 준비했으니 그걸 쓰시면 됩니다.

다운로드

컬러 버전: 만다라트_플래너.html
흑백 인쇄용: 만다라트_플래너_흑백.html

만다라트_플래너.html

0.01MB

만다라트_플래너_흑백.html

0.01MB

예시

컬러 버전

흑백 버전

AI는 왜 아직 사람을 대체하지 못하는가 — 퀀트 트레이딩이 주는 힌트

Deepmind_딥마인드 — Sun, 12 Apr 2026 14:18:26 +0900

3편에서 멀티에이전트의 현실적 한계를 짚었다. 이번엔 그 한계가 어디서 오는지 본질을 이야기한다.

AI가 사람을 완전히 대체하기 힘든 이유를 한 문장으로 정리하면 이렇다. AI는 데이터를 읽지만, 사람은 맥락을 읽는다.

데이터에 가까울수록 AI가 강하다

모든 직무가 동일하게 대체되지는 않는다. 하나의 스펙트럼으로 볼 수 있다.

사용자 ←------------------------------→ 데이터
       영업, CS, 기획    퀀트, DBA, ML엔지니어
       ← 사람이 강한 영역   AI가 강한 영역 →

사용자와 직접 맞닿아 있는 계층일수록 사람이 필요하다. 고객의 말 뒤에 숨은 감정, 아직 언어화되지 않은 불편함, 관계에서 오는 신뢰. 이런 것들은 데이터로 포착되지 않는다.

반대로 데이터에 가까울수록 AI의 의존도가 높아진다. 사람이 다 잡아내기 힘든 패턴을 빅데이터에서 찾아내는 일, 수천 개의 변수를 동시에 고려하는 일. AI가 진짜 강한 영역이다.

퀀트 트레이딩이 주는 힌트

그 경계가 가장 선명하게 드러나는 곳이 주식시장이다.

기업의 어닝서프라이즈가 나와도 주가가 급락하는 경우가 흔하다. 실적 숫자는 완벽한데, 사회 한 축의 작은 불안이 시장 전체를 흔든다. 주가는 기업의 실적이 아니라 그 실적을 시장이 어떻게 받아들이는지가 결정한다. 그리고 그 받아들임에는 인간의 감정이 들어있다.

퀀트 트레이딩은 그 감정을 배제하고 수학적 통계와 수치로만 시장을 해석한다. AI가 가장 잘할 수 있는 방식이다. 방대한 데이터, 명확한 수치, 빠른 판단.

그런데 퀀트 트레이딩으로 꾸준히 돈을 버는 회사가 드물다. 르네상스 테크놀로지 같은 극소수의 예외가 있지만, 대부분은 시장을 이기지 못한다. 왜냐하면 시장은 데이터만으로 움직이지 않기 때문이다.

AI로 회사를 대체하는 것도 마찬가지다

퀀트가 시장을 완전히 정복하지 못하는 이유와, AI가 조직을 완전히 대체하지 못하는 이유는 같다.

현실은 수치로 환원되지 않는 변수들로 가득하다. 고객이 무엇을 원하는지, 팀원이 왜 그 결정에 저항하는지, 지금 이 타이밍에 이 기능을 출시하는 게 맞는지. 이런 판단들은 데이터에서 나오지 않는다. 축적된 경험과 관계와 감각에서 나온다.

AI는 명확한 기준이 있는 곳에서 강하다. 합격/불합격이 있는 테스트, 수치로 측정되는 성과, 반복 가능한 패턴. 하지만 회사에서 실제로 중요한 결정들은 대부분 그 기준 자체를 만드는 일이다. 무엇을 만들지, 왜 지금인지, 어디까지 할지. 이건 데이터 문제가 아니라 판단의 문제다.

결국 남는 질문

AI가 대체하는 건 직무가 아니라 직무 안의 특정 작업이다. 그리고 그 작업들은 공통점이 있다. 반복적이고, 수치화 가능하고, 기준이 명확한 것들.

반대로 사람이 남는 영역도 공통점이 있다. 기준을 만드는 일, 감정을 읽는 일, 책임을 지는 일.

퀀트 트레이딩이 시장을 이기기 어렵듯, AI로 회사를 통째로 돌리기는 아직 요원하다. 둘 다 같은 이유에서다. 세상은 데이터보다 복잡하고, 사람은 수치보다 감정적이다.

다만 퀀트가 전통적인 펀드매니저의 일하는 방식을 바꿔놓았듯, AI도 조직이 일하는 방식을 조용히 바꾸고 있다. 대체가 아니라 변형. 그게 지금 일어나고 있는 일의 정확한 이름일 것이다.

이 시리즈의 출발점은 Youtube @HONGLAB의 <드디어 C++ 무너지나> 였다.

AI로 회사를 대체한다는 것 — 이론과 현실 사이

Deepmind_딥마인드 — Sun, 12 Apr 2026 14:13:16 +0900

2편에서 멀티에이전트 조직 구조를 설계했다. 이번엔 그게 실제로 되는지 확인할 차례다.

설계는 그럴듯했다. CTO 에이전트가 오케스트레이션하고, 기획자 에이전트가 요구사항을 정의하고, 백엔드 에이전트가 구현하고, QA가 검증하고, 인프라가 배포한다. 카카오 조직도를 그대로 에이전트로 바꾼 구조. 이론적으로는 완벽했다.

그런데 긱뉴스에서 글 하나를 읽었다. Gastown과 Paperclip을 실제로 써본 사람의 후기였다. API 토큰 비용으로 $5,000을 썼고, 결론은 냉정했다.

토큰 비용은 단일 에이전트 대비 5~10배 소비되는데 생산성이 비례하지 않았다.

실제로 무너지는 지점

멀티에이전트가 막히는 곳은 생각보다 단순하다.

첫째, 맥락이 이어지지 않는다. 기획자 에이전트가 백엔드 에이전트에게 요구사항을 넘기는 순간, 그 안에 담긴 "왜 이렇게 결정했는지"가 사라진다. 요약 보고서로 넘기면 토큰은 아낄 수 있지만 맥락도 같이 잘린다. 에이전트가 코드는 읽어도 의도는 읽지 못한다.

둘째, "완료" 판단을 믿을 수 없다. QA 에이전트가 통과 사인을 냈는데 실제로는 중요한 케이스를 빠뜨렸을 수 있다. 에이전트는 기술적으로 유효하지만 핵심을 놓치는 테스트를 작성할 수 있다. 틀린 결과를 스스로 완료로 처리하는 문제가 반복된다는 게 실제 사용자의 경험이었다.

셋째, 병목이 이동했다. 코드 생성은 빨라졌는데 검증이 오히려 더 어려워졌다. 40개 에이전트가 동시에 코드를 쏟아낼 때, 그게 맞는지 확인하는 건 여전히 사람 몫이다. 생산성이 올라간 게 아니라 병목의 위치가 바뀐 것이다.

"도시"나 "회사" 메타포가 왜 안 먹히나

에이전트를 회사 조직도처럼 배치하는 접근이 매력적으로 보이는 이유는, 우리가 이미 그 구조를 이해하고 있기 때문이다. CEO가 지시하고 팀장이 분배하고 팀원이 실행한다. 직관적이다.

문제는 실제 회사가 그렇게 돌아가지 않는다는 거다. 팀장은 위아래 눈치를 보면서 요구사항을 현실에 맞게 깎아내고, 팀원은 "이건 이렇게 하면 안 됩니다"라고 밀어붙인다. 그 마찰 속에서 결과물이 나온다. 에이전트는 지시는 잘 따르지만 마찰을 만들지 못한다.

조직도는 권한과 책임의 구조인데, 에이전트한테는 책임이 없다. 장애가 나도 "에이전트가 배포했습니다"로 끝나지 않는다.

그러면 지금 당장 가능한 건 뭔가

현재 가장 잘 작동하는 구조는 사람 한 명이 오케스트레이터가 되는 형태다.

나 (오케스트레이터)
├── 에이전트 A: 범위 명확한 태스크
├── 에이전트 B: 범위 명확한 태스크
└── 결과 검증: 내가 직접

에이전트한테 맡길 수 있는 것과 없는 것의 기준이 생긴다.

맡길 수 있는 것 — 합격/불합격 기준이 명확한 태스크, 보일러플레이트, 마이그레이션, 테스트 스캐폴딩.

직접 해야 하는 것 — 아키텍처 설계, "만들지 않을 것"을 결정하는 일, 에이전트 출력 전체를 시스템 맥락으로 검토하는 일.

완전 자율 조직이 아니라, 한 명이 여러 에이전트를 끌고 10명짜리 팀과 경쟁하는 구조. 이게 지금 현실에서 가능한 최대치에 가깝다.

이론은 맞는데 현실은 아직 멀다

1편에서 "압축이 일어난다"고 했다. 개발자가 사라지는 게 아니라 1명이 더 많은 걸 커버하게 된다고. 그 방향은 맞는다. 하지만 그 압축이 완전한 자동화로 이어지기까지는 아직 몇 가지 구조적 문제가 남아 있다.

맥락의 연속성, 검증의 신뢰성, 책임의 소재.

이 세 가지가 해결되지 않으면 에이전트 조직은 빠른 실행 도구일 뿐, 판단하는 조직은 될 수 없다. 그리고 판단이 없는 조직은 회사가 아니다.

당분간 가장 강력한 구조는 여전히 사람이 중심에 있는 형태일 것이다. 다만 그 사람이 혼자 할 수 있는 일의 범위가, 조용히 넓어지고 있다.

긱뉴스의 멀티에이전트 관련 글들을 읽고

https://news.hada.io/topic?id=28303

코드 에이전트 오케스트라 - 멀티 에이전트 코딩을 제대로 작동시키는 법 | GeekNews

단일 AI 어시스턴트와 동기적 루프로 협업하던 방식에서, 여러 에이전트가 각자의 컨텍스트 윈도우와 파일 범위를 가지고 비동기적으로 동작하는 오케스트레이터 모델로의 전환이 2026년 현재

news.hada.io

https://news.hada.io/topic?id=28283

멀티 에이전트 오케스트레이션은 왜 잘 안 되는가? | GeekNews

최근 AI로 “제로 휴먼 컴퍼니” 를 운영할 수 있게 해주는 ‘Paperclip’ 프로젝트가 이슈가 되었는데요. 에이전트들을 회사 조직도처럼 구성해서 CEO, 팀장, 실무자 역할을 부여하고 회사의 미션

news.hada.io

https://news.hada.io/topic?id=27560

oh-my-agent — 실무용 멀티 AI IDE 에이전트 하네스 | GeekNews

에이전트에게 “TODO 앱 만들어줘”라고 하면 뭔가를 만들긴 합니다. 문제는 자주 엉뚱한 걸 만들고, 범위를 벗어나고, 같은 실수를 반복한다는 점입니다.이런 문제를 해결하려고 초기엔 AGENTS.md,

news.hada.io

AI 시대, 회사도 대체될 수 있을까 — 멀티에이전트 조직 설계

Deepmind_딥마인드 — Sun, 12 Apr 2026 13:29:49 +0900

앞선 글에서 개발자 개인이 AI에 의해 압축되는 흐름을 이야기했다. 이번엔 그 스케일을 조직 전체로 올려본다.

개발자 한 명이 대체된다면, 팀도 대체될 수 있지 않을까. 팀이 된다면 부서도. 부서가 된다면 회사 전체도.

이론적으로는 완전히 가능한 구조다. 각 팀원을 서브에이전트로 두고, 팀장 에이전트가 조율하고, 부서장 에이전트가 그 위를 관리하는 계층 구조. Multi-agent 오케스트레이션이라는 기술적 프레임은 이미 존재한다.

회사는 단순한 실행 구조가 아니다

문제는 회사가 "지시 → 실행 → 검증" 루프만으로 돌아가지 않는다는 점이다. 실제 조직에서 일어나는 대부분은 불완전한 정보 속에서 이해관계를 조율하는 과정이다.

팀장이 팀원에게 일을 시키는 게 아니라, 팀장이 위아래 눈치를 보면서 요구사항을 현실에 맞게 깎아내고, 팀원이 "이건 이렇게 하면 안 됩니다"라고 밀어붙이고, 그 마찰 속에서 결과물이 나온다. AI 에이전트 계층은 지시는 잘 따르지만 마찰을 만들지 못한다. 역설적으로 그 마찰이 품질을 만드는 경우가 많은데.

그래서 AI로 대체 가능한 조직에는 조건이 생긴다.

요구사항이 명확하게 정의될 수 있는 도메인
결과물의 품질을 객관적으로 검증할 수 있는 도메인
실패 비용이 낮거나 롤백이 가능한 도메인

B2B SaaS처럼 스펙이 비교적 명확한 곳은 빠르게 잠식될 수 있다. 반면 컨설팅이나 정치적 의사결정이 많은 대기업 내부 조직은 훨씬 느릴 거다.

실제로 어떻게 설계할까

카카오의 조직도를 보면 에이전트 구조와 거의 1:1 매핑이 된다.

오케스트레이터 (CTO 에이전트)
├── 기획/PM 에이전트
├── Frontend 에이전트
├── Server 에이전트
├── Infra 에이전트
├── Database 에이전트
├── QA 에이전트
├── Security 에이전트
└── Technical Writing 에이전트

하지만 카카오 구조를 그대로 구현하면 안 된다. 카카오는 수천 명 조직이라 각 팀이 독립적으로 굴러가도 되지만, 에이전트 구조에서 모든 팀을 다 돌리면 비용이 폭발한다. 기능 요청 하나에 12개 에이전트가 전부 개입할 필요가 없다.

현실적인 접근은 온디맨드 호출이다. 오케스트레이터가 요구사항을 분석한 뒤 필요한 에이전트만 선택적으로 호출한다.

로그인 기능 추가 요청
→ Server + Database + Security + QA만 호출
→ Data Science, Hadoop은 이번엔 스킵

플로우: 기획부터 배포까지

에이전트 간 통신에서 핵심은 풀 컨텍스트를 넘기지 않는 것이다. 대신 요약 보고서 형태로 인계한다.

기획자 에이전트
    ↓ 요구사항 명세서 (요약본)
백엔드 에이전트  ←→  파일시스템 (코드 직접 읽고 씀)
    ↓ 구현 완료 보고서 (요약본)
기획자 에이전트 (검토) → 수정 요청 시 루프
    ↓ OK 사인
QA 에이전트  ←→  파일시스템 (코드 읽고 테스트)
    ↓ QA 통과 보고서 (요약본)
인프라 에이전트 (배포 전략 수립)
    ↓ 전체 요약 패키지
최고관리자 에이전트 (최종 승인)

각 에이전트가 다음 에이전트에게 넘길 때 이런 형태의 보고서만 전달한다.

[인계 보고서]
- 요구사항: 로그인 기능 구현
- 구현 내역: JWT 인증, /auth/login 엔드포인트
- 변경 파일: src/auth/AuthController.java
- 미결 사항: 없음
- 다음 담당: QA

풀 대화 히스토리 대신 이 보고서만 넘기면 토큰이 극적으로 줄어든다. 그리고 각 에이전트는 공유 파일시스템에 직접 접근해서 코드를 읽고 쓴다. 코드 전체를 컨텍스트로 받는 게 아니라 필요한 파일만 그때그때 읽는 방식이다. Claude Code가 실제로 이렇게 동작한다.

/workspace
├── /server        # Server 에이전트 작업 공간
├── /frontend      # Frontend 에이전트 작업 공간
├── /reports       # 공유 보고서
│   ├── requirements.md
│   ├── api_spec.md   ← 팀간 계약서 역할
│   └── qa_report.md
└── /context       # 오케스트레이터 상태

팀 간 직접 대화보다 api_spec.md 같은 계약 문서를 중간에 두고 비동기로 통신하는 방식이 실제 협업 구조와도 맞고, 컨텍스트도 절약된다.

더 현실적인 첫 번째 시나리오

회사 전체를 한 번에 대체하는 게 아니라, 스타트업 1인 창업자가 AI 에이전트 팀을 끌고 10명짜리 팀과 경쟁하는 구조가 먼저 올 것 같다. 이미 그런 사례들이 나오고 있다. 그게 쌓이면 자연스럽게 "이 규모의 팀이 필요한가"라는 질문이 조직 단위로 올라오게 된다.

회사도 대체되는 게 아니라 압축되는 거다.

그리고 그 압축된 구조를 실제로 구축해보고 싶어졌다. 우분투 서버 하나, Anthropic API, LangGraph. 일단 오케스트레이터 + Server 에이전트 + QA 에이전트 3개짜리 미니 회사부터 시작해볼 생각이다.

이 생각의 출발점은 Youtube @HONGLAB의 <드디어 C++ 무너지나> 였다.

AI 시대, 개발자는 어디까지 살아남을까

Deepmind_딥마인드 — Sun, 12 Apr 2026 00:38:06 +0900

홍랩의 영상 하나를 보다가 생각이 길어졌다.

C++이 Rust에게 무너질 것인가. 댓글 반응은 대체로 회의적이었다. 언어는 쉽게 대체되지 않는다. COBOL이 수십 년째 금융권에서 살아있듯, C++도 그 방대한 코드베이스와 생태계의 무게로 버텨낼 것이다. "대체"가 아니라 "영역 분리"가 일어날 뿐이라고.

그 댓글들을 읽으면서 자연스럽게 다른 질문으로 넘어갔다. 그럼 개발자는?

AI가 개발자를 완전히 대체하려면 이론적으로 하나의 조건이 필요하다. 모든 코드베이스, 모든 요구사항, 모든 문서가 AI 모델의 컨텍스트 안에 들어와야 한다. 지금 당장은 불가능하다. 하지만 RAG, 서브에이전트 오케스트레이션, 점점 늘어나는 컨텍스트 윈도우를 보면, 이 장벽은 사실 가장 빠르게 허물어질 것들 중 하나일 수 있다.

더 근본적인 장벽은 따로 있다. 코드가 아니라 암묵지다. 왜 이 설계를 택했는지, 이 요구사항이 어떤 맥락에서 나왔는지, 이해관계자들 사이의 역학, 레거시가 왜 이 모양인지. 이런 것들은 문서화조차 안 돼 있고, 컨텍스트에 넣을 수조차 없다. AI는 코드를 읽을 수 있어도 조직의 역사는 읽지 못한다.

잠식은 아마 이런 순서로 올 것이다.

모듈 → 기능 → 서비스 → 도메인 → 국가

각 계층마다 저항점이 다르다. 모듈과 기능 레벨은 이미 상당히 잠식됐다. 유지보수, 작은 기능 추가, 버그 수정. 커맨드 AI가 팀 단위 서브에이전트를 호출하는 구조로 충분히 가능한 영역이다.

서비스 레벨부터는 도메인 전문성과 비즈니스 판단이 섞이고, 도메인 레벨부터는 규제와 책임이 섞인다. 속도가 급격히 느려지는 구간이 거기다. "AI가 배포했습니다"로 장애 책임이 끝나지 않는 한, 판단하고 서명하고 책임지는 사람은 남아야 한다. 이건 기술 문제가 아니라 사회 제도의 문제다.

결국 남는 사람은 어떤 사람일까.

단순히 요구사항을 받아 설계하는 사람이 아닐 것이다. AI 여러 개가 만들어낸 결과물 사이의 모순을 발견하고 중재할 수 있는 사람. 시스템 전체를 이해하면서 AI 출력을 검증하는 사람. 어쩌면 지금보다 훨씬 높은 수준의 엔지니어링 감각을 요구하게 될 수도 있다.

1명이 수십 명 몫의 코드와 도메인을 이해하고, 요구사항을 타협하며 풀어내고, 구현을 감독하고 검증하고 배포까지. 대체가 아니라 압축이 일어나는 것이다.

C++이 Rust로 대체되는 게 아니라 영역이 분리되듯, 개발자도 사라지는 게 아니라 역할이 올라가는 것일지 모른다. 추상화 레이어가 높아질수록 더 높은 곳에서 사고하는 사람만 남는다는 패턴, 역사는 계속 그걸 반복해왔다.

다만 그 압축의 과정에서 얼마나 많은 자리가 사라질지는, 아직 아무도 모른다.

Youtube @HONGLAB <드디어 C++ 무너지나> 를 보고

서로 존중하며 다양한 의견을 내주시는건 환영입니다.

[백준] C++ 14890번 경사로

Deepmind_딥마인드 — Wed, 8 Apr 2026 23:11:58 +0900

#include <bits/stdc++.h>
using namespace std;
int n, l, a[104][104], b[104][104], ret;

void sol(int a[104][104]) {
    for (int i = 0; i < n; i++) {
        int cnt = 1; // cnt 가 1일때는 현재 자리에 슬라이드가 안깔려 있는 맨 땅임, 또 앞으로는 j + 1을 바로 읽기 때문에 1을 초기값으로 설정함
        int j; // 한 행이 끝나면 그 길의 끝까지 도달했는지 체크하기 위해 for문에서 뺐음
        for (j = 0; j < n - 1; j++) { // + 1 한 위치를 보므로 경계값 - 1 해둔다
            if (a[i][j] == a[i][j + 1]) {
                cnt++;
            }
            else if (a[i][j] + 1 == a[i][j + 1] && cnt >= l ) { // 앞 칸이 + 1높이 이고 && 뒤를 봤을 때 지나온 길에 오르막을 만들 수 있는지 (l 보다 현재까지 지나온 길이 길거나 같으면 놓을 수 있음)
                cnt = 1; // 지나온 길 카운팅 리셋, cnt 가 1일때는 현재 자리에 경사로가 안깔려 있는 맨 땅임
            }
            else if (a[i][j] - 1 == a[i][j + 1] && cnt >= 0) { // 앞칸이 -1 높이이고 && 현재 자리에 경사로를 깔지 않은 상태 일때만 가능 (cnt가 음수일 경우엔 이전에 깔았던 내리막이 아직 안끝난 자리임, 그러므로 현재 자리는 빈땅이 아니므로 내리막을 놓을 수 없음)
                cnt = -l + 1; // 앞으로 l 칸만큼 깔아줌, + 1 한 이유는 앞에서도 이야기 했듯이 j + 1을 바로 읽기 때문에 1을 초기값으로 생각한다.
            }
            else break;
        }         
        if (j == n - 1 && cnt >= 0) { // 한 행이 무사히 끝 && 마지막 칸에 무사히 경사로의 끝이던가 아니면 맨땅이던가
            ret++;
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL); cout.tie(NULL);

    cin >> n >> l;
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            cin >> a[i][j];
            b[j][i] = a[i][j];
        }
    }
    sol(a); 
    sol(b);
    cout << ret << "\n";

    return 0;
}

[LLM Server 구축기] 폐쇄망 환경에서 로컬 코딩 에이전트 파일럿 만들기

Deepmind_딥마인드 — Sun, 5 Apr 2026 13:14:40 +0900

(26.04.04 기준)

1. Why?

최근 Claude Code 유출 이슈가 화제가 됐다. Claude Code 측에서 npm 배포 과정 중 ignore 설정 실수로 src 파일이 통째로 포함되면서 내부 구현이 외부에 노출된 사건이었다. 이 일을 보면서 “코딩 에이전트는 실제로 어떤 구조로 동작하는가”에 대한 관심이 생겼다.

하지만 이 글의 출발점은 단순한 호기심만은 아니었다. 내가 일하는 회사는 폐쇄망 환경이라 외부 SaaS 기반 AI 도구를 도입하는 데 제약이 있었다. 그 와중에 PM님이 “AI 시대에 맞춰 사내에도 AI를 도입해 개발 생산성을 높여보자”는 제안을 주셨고, 그에 따라 폐쇄망에서 실제로 굴릴 수 있는 AI 코딩 에이전트 파일럿 프로젝트를 해보기로 했다.

이 글은 그 과정에서 시도한 인프라 구성, 시행착오, 그리고 목표를 어떻게 수정했는지를 정리한 기록이다.

2. 처음 목표와 수정된 목표

처음에는 Claude Code처럼 잘 동작하는 로컬 코딩 에이전트를 만들고 싶었다. 실제로 Claude Code와 Ollama를 연결해보기도 했다. Ollama 공식 문서도 Claude Code 연결을 안내하고 있기 때문에, “로컬 모델만 준비되면 비슷한 개발 경험을 만들 수 있지 않을까”라고 생각했다.

하지만 진행하면서 현실적인 제약이 분명히 보였다.

현재 내가 사용한 서버 환경은 다음과 같다. 집에 있던 데스크탑이라 사양이 낮다.

GTX 1070 8GB
Ollama
qwen2.5-coder:7b

이 조합은 “가벼운 로컬 코딩 보조” 정도는 가능했지만, Claude Code가 기대하는 수준의 에이전트 워크플로를 안정적으로 수행하기에는 부족했다. Claude Code는 긴 system prompt, tool use, permission, session state를 전제로 움직이는데, Ollama 문서 기준으로도 Claude Code 사용 시 최소 64K context를 권장한다. 반면 내 환경에서 실제로 확인된 context는 4K 수준이었다.

CONTEXT를 보면 알 수 있다.

즉 문제는 단순히 “모델이 연결되느냐”가 아니라, “에이전트가 기대하는 long context와 tool protocol을 현재 하드웨어가 감당할 수 있느냐”였다.

그래서 목표를 다음과 같이 수정했다.

수정된 목표: 폐쇄망 환경에서 동작하는 로컬 코딩 에이전트 파일럿

이 목표에서는 Claude Code와의 완전한 parity는 포기하고, 대신 아래를 더 중요하게 보기로 했다.

폐쇄망에서 실제로 설치/운영 가능한가
내부 LLM 서버와 연결 가능한가
파일 읽기/쓰기/수정, 명령 실행이 가능한가
권한 통제와 세션 유지가 가능한가
실제 개발 저장소에서 생산성 향상이 있는가

참고:

Claude Code - Ollama

Claude Code - Ollama

docs.ollama.com

3. 최종 인프라 구성

이번 파일럿의 최종 인프라 구성은 다음과 같다.

Ubuntu Server 24.04.4 LTS
NVIDIA Driver 580.126.20
Ollama
qwen2.5-coder:7b
GPU: GTX 1070 8GB
로컬 클라이언트: macOS
내부망에서 Ollama endpoint 호출

구조를 단순하게 그리면 아래와 같다.

macOS에서 CLI 실행
내부망으로 Ubuntu 서버의 Ollama 호출
Ubuntu 서버가 qwen2.5-coder:7b 모델 추론 수행

즉, 클라이언트와 모델 서버를 분리한 구조다.

4. 서버 구축 절차

4.1 기본 패키지 설치

먼저 기본 패키지를 설치했다.

sudo apt update
sudo apt install -y curl ca-certificates git ufw

이 단계는 설치 스크립트 실행과 API 확인용 curl 같은 기본 도구를 준비하기 위한 것이다.

4.2 NVIDIA 드라이버 설치

이후 NVIDIA 드라이버를 설치했다.

sudo apt install -y ubuntu-drivers-common
sudo ubuntu-drivers list --gpgpu
sudo ubuntu-drivers install --gpgpu
sudo reboot

재부팅 후에는 반드시 아래 명령으로 GPU가 정상 인식되는지 확인해야 한다.

nvidia-smi

여기서 GPU가 정상적으로 보이지 않으면 다음 단계로 넘어가지 않는 것이 맞다.

4.3 Ollama 설치

Ollama는 Ubuntu 서버에 직접 설치했다.

curl -fsSL https://ollama.com/install.sh | sh
sudo systemctl enable --now ollama
sudo systemctl status ollama
ollama -v

4.4 외부 바인딩 및 모델 저장 경로 설정

로컬 macOS에서 dev-agent 같은 클라이언트가 원격 서버의 Ollama에 붙을 수 있도록 서비스 override를 설정했다.

sudo mkdir -p /srv/llm-project/models/ollama
sudo chown -R ollama:ollama /srv/llm-project/models/ollama
sudo mkdir -p /etc/systemd/system/ollama.service.d
sudo tee /etc/systemd/system/ollama.service.d/override.conf >/dev/null <<'EOF'
[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_MODELS=/srv/llm-project/models/ollama"
EOF
sudo systemctl daemon-reload
sudo systemctl restart ollama

이 단계가 중요한 이유는 Ollama가 기본적으로 127.0.0.1:11434에만 바인드되기 때문이다.

4.5 방화벽 설정

보안상 가장 좋은 방법은 특정 개발 PC의 IP만 허용하는 방식이지만, 나는 같은 공유기 내부망에서 우선 빠르게 테스트하는 것이 목적이었기 때문에 임시로 아래처럼 포트를 열었다.

sudo ufw allow 11434/tcp

상태 확인:

sudo ufw status

4.6 모델 다운로드

내 데스크탑 서버는 GTX 1070 8GB이기 때문에 현실적으로 7B 모델을 선택했다.

ollama pull qwen2.5-coder:7b

모델 정보:

qwen2.5-coder

qwen2.5-coder

The latest series of Code-Specific Qwen models, with significant improvements in code generation, code reasoning, and code fixing.

ollama.com

qwen2.5-coder는 코드 생성, 코드 reasoning, 코드 수정에 특화된 Qwen 계열 모델이다.

4.7 서버 로컬 확인

설치 후 서버 내부에서 Ollama가 정상 동작하는지 확인했다.

curl http://127.0.0.1:11434/api/tags
curl http://127.0.0.1:11434/api/generate -d '{
  "model": "qwen2.5-coder:7b",
  "prompt": "say ok",
  "stream": false
}'
ollama ps

여기서 ollama ps를 보면 모델이 GPU로 올라갔는지, 그리고 실제 context가 얼마인지 확인할 수 있다.

간단한 테스트만 할 거라면 CPU fallback이어도 일단 동작은 가능하다. 하지만 본격적으로 사용할 경우 속도 차이가 크기 때문에 GPU 사용 여부는 꼭 확인하는 것이 좋다.

5. 실제로 부딪힌 문제

5.1 NVML mismatch

처음에는 GPU가 전혀 잡히지 않았다.

nvidia-smi

출력은 다음과 같았다.

Failed to initialize NVML: Driver/library version mismatch
NVML library version: 595.58

알고 보니 NVIDIA 드라이버 버전과 유저 공간 라이브러리 버전이 서로 맞지 않아 GPU를 정상적으로 사용할 수 없는 상태였다.

5.2 NVIDIA 드라이버 커널 모듈 문제

이후에는 다음과 같은 오류도 만났다.

NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver.
Make sure that the latest NVIDIA driver is installed and running.

즉, NVIDIA 드라이버 커널 모듈 자체가 정상적으로 올라오지 않는 상태였다.

5.3 apt dependency broken

드라이버를 다시 설치하려고 했을 때는 apt 상태도 깨져 있었다.

sudo apt install -y ubuntu-drivers-common mokutil

실행 결과:

E: Unmet dependencies. Try 'apt --fix-broken install' with no packages (or specify a solution).

결국 드라이버 문제를 해결하기 전에 패키지 의존성부터 복구해야 했다.

복구 절차는 다음과 같았다.

sudo apt --fix-broken install
sudo apt autoremove -y
sudo apt update
sudo ubuntu-drivers list --gpgpu
sudo ubuntu-drivers install --gpgpu
sudo reboot
nvidia-smi

5.4 GTX 1070과 최신 드라이버의 함정

추가로 확인해보니, GTX 1070은 최신 595 계열 드라이버보다 580 계열 legacy 쪽이 더 맞는 조합이었다. 최종적으로 정상 동작한 버전은 580.126.20이었다.

이 과정을 통해 단순히 “드라이버를 설치한다”가 아니라, GPU 세대에 맞는 드라이버 브랜치를 선택하는 것이 중요하다는 걸 배웠다.

6. 왜 Claude Code를 그대로 목표로 하지 않았는가

설치와 연결 자체는 가능했다. 실제로 로컬에 설치된 Claude Code CLI를 Ollama endpoint에 연결하는 것까지는 성공했다.

문제는 품질이었다.

qwen2.5-coder:7b 같은 작은 모델은 Claude Code가 기대하는 tool protocol과 long context를 안정적으로 처리하지 못했다. 단순한 프롬프트에는 반응했지만, 실제 파일 읽기/skill/tool 선택이 들어가면 엉뚱한 structured output이나 잘못된 skill 호출이 튀어나왔다.

이건 Claude Code 자체의 문제라기보다는, 현재 하드웨어와 모델 조합의 한계에 가까웠다.

결국 여기서 얻은 결론은 이랬다.

Claude Code와 비슷한 UX를 만드는 것보다
폐쇄망에서 실제로 쓸 수 있는 에이전트를 만드는 것이 더 중요하다

그래서 나는 Claude Code 복제를 목표로 삼는 대신, 현재 인프라에서 돌아가는 로컬 코딩 에이전트 파일럿으로 방향을 바꿨다.

7. 배운 점

이번 파일럿을 하면서 얻은 핵심 교훈은 아래와 같다.

에이전트는 단순 채팅 모델과 다르다
tool use, permission, session, long context가 핵심이다
작은 모델은 연결 자체보다 “에이전트형 동작”에서 한계를 드러낸다
폐쇄망에서는 최고 성능보다 운영 가능성과 통제 가능성이 더 중요하다
목표를 이상적으로 잡는 것보다, 현재 인프라에서 가능한 범위로 조정하는 것이 더 중요하다

8. 다음 단계

다음 단계는 Claude Code 복제가 아니라, 폐쇄망에서 실제로 사용할 수 있는 코딩 에이전트 파일럿을 더 구체화하는 것이다.

예를 들면 아래 기능들이 우선순위가 될 수 있다.

파일 읽기/쓰기/수정
쉘 명령 실행
권한 승인
세션 저장/복구
간단한 감사 로그
실제 백엔드 저장소 대상 파일럿 검증

이제 목표는 “Claude Code처럼 보이는 도구”가 아니라, “사내 폐쇄망에서 실제로 개발 생산성을 올릴 수 있는 도구”다.

[백준] C++ 6593번:상범 빌딩!

Deepmind_딥마인드 — Wed, 17 Dec 2025 09:38:40 +0900

생각할 것

1. 몇번째 인지 dist 벡터에 기록

2. 테케 여러개 있음

<정답 코드>

#include <bits/stdc++.h>
using namespace std;

int dx[6] = {1, 0, -1, 0, 0, 0};
int dy[6] = {0, 1, 0, -1, 0, 0};
int dz[6] = {0, 0, 0, 0, 1, -1};

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    
    int l, r, c;
    cin >> l >> r >> c;

    while (l != 0 && r != 0 && c != 0) {
        int flag = 0;
        vector<vector<vector<char>>> v (l, vector<vector<char>> (r, vector<char> (c)));
        vector<vector<vector<int>>> dis (l, vector<vector<int>> (r, vector<int> (c, -1)));
        int sy, sx, sz;
        int ez, ey, ex;
        for (int ll = 0; ll < l; ll++) {
            for (int rr = 0; rr < r; rr++) {
                for (int cc = 0; cc < c; cc++) {
                    cin >> v[ll][rr][cc];
                    if (v[ll][rr][cc] == 'S') {
                        sz = ll;
                        sy = rr;
                        sx = cc;
                    }
                    if (v[ll][rr][cc] == 'E') {
                        ez = ll;
                        ey = rr;
                        ex = cc;
                    }
                }
            }
        }
        queue<tuple<int, int, int>> q;
        q.push(make_tuple(sz, sy, sx));
        dis[sz][sy][sx] = 0;
        while(!q.empty()) {
            auto cur = q.front();
            q.pop();
            for (int i = 0; i < 6; i++) {
                int zz = get<0>(cur) + dz[i];
                int yy = get<1>(cur) + dy[i];
                int xx = get<2>(cur) + dx[i];
                if (zz > -1 && zz < l && yy > -1 && yy < r && xx > -1 && xx < c && (v[zz][yy][xx] == '.' || v[zz][yy][xx] == 'E') && dis[zz][yy][xx] == -1) {
                    if (zz == ez && yy == ey && xx == ex) {
                        cout << "Escaped in " << dis[get<0>(cur)][get<1>(cur)][get<2>(cur)] + 1 << " minute(s).\n";
                        flag = 1;
                        break;
                    }
                    q.push(make_tuple(zz, yy, xx));
                    dis[zz][yy][xx] = dis[get<0>(cur)][get<1>(cur)][get<2>(cur)] + 1;
                }
            }
            if (flag) break;
        }
        if (!flag) cout << "Trapped!\n";
        cin >> l >> r >> c;
    }
    

    return 0;
}

[백준] C++ 2468번:안전영역!

Deepmind_딥마인드 — Tue, 16 Dec 2025 22:42:48 +0900

생각할 것

1. 모든 경우에 가장 많은 안전구역이 생기는 때를 찾으려면 -> for (min ... max) 순회하여 BFS 한다.

<정답 코드>

#include <bits/stdc++.h>
using namespace std;

int dy[4] = {1, 0, -1, 0};
int dx[4] = {0, 1, 0, -1};

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);

    int n;
    cin >> n;
    vector<vector<int>> v (n, vector<int>(n, -1));
    int min = 0, max = 0;
    for (int y = 0; y < n; y++) {
        for (int x = 0; x < n; x++) {
            cin >> v[y][x];
            if (v[y][x] < min) {
                min = v[y][x];
            }
            if (v[y][x] > max) {
                max = v[y][x];
            }
        }
    }
    int area = 0;

    for (int hi = min; hi <= max; hi++) {
        queue<pair<int, int>> q;
        vector<vector<int>> vis (n, vector<int>(n, 0));
        int curArea = 0;
        for (int y = 0; y < n; y++) {
            for (int x = 0; x < n; x++) {
                // 현재 수심보다 높으면 탐색 시작
                if (v[y][x] > hi && vis[y][x] == 0) {
                    curArea++;
                    q.push({y, x});
                    vis[y][x] = 1;
                    while (!q.empty()) {
                        auto cur = q.front();
                        q.pop();
                        for (int i = 0; i < 4; i++) {
                            int yy = cur.first + dy[i];
                            int xx = cur.second + dx[i];
                            if (yy > -1 && yy < n && xx > -1 && xx < n && v[yy][xx] > hi && vis[yy][xx] == 0) {
                                q.push({yy, xx});
                                vis[yy][xx] = 1;
                            }
                        }
                    }
                }
            }
        }
        if (curArea > area) {
            area = curArea;
        }
    }
    cout << area;

    return 0;
}

[백준] C++ 5014번:스타트링크!

Deepmind_딥마인드 — Tue, 16 Dec 2025 10:09:53 +0900

생각할 것

1. 벡터 선언 범위

2. 인덱스 시작이 0인지 1인지 확인

<정답 코드>

#include <bits/stdc++.h>
using namespace std;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);

    int f, s, g, u, d;
    cin >> f >> s >> g >> u >> d;

    vector<int> v (f + 1, -1);
    queue<int> q;
    if (s == g) {
        cout << 0;
        return 0;
    }
    q.push(s);
    v[s] = 0;
    while (!q.empty()) {
        int cur = q.front();
        q.pop();
        int ss = cur + u;
        if (ss > 0 && ss <= f && v[ss] == -1) {
            if (ss == g) {
                cout << v[cur] + 1;
                return 0;
            }
            q.push(ss);
            v[ss] = v[cur] + 1;
        } 
        ss = cur - d;
        if (ss > 0 && ss <= f && v[ss] == -1) {
            if (ss == g) {
                cout << v[cur] + 1;
                return 0;
            }
            q.push(ss);
            v[ss] = v[cur] + 1;
        } 
    }
    cout << "use the stairs";
    
    return 0;
}