• 제목 : PM은 LLM을 어디까지 이해해야 할까?
• 출처 : 요즘 IT
• 기사 링크 : https://yozm.wishket.com/magazine/detail/3784/

📖 기사 핵심 요약

• LLM(대규모 언어 모델)은 복잡한 사고를 하는 것이 아니라, 다음에 올 단어를 확률적으로 예측하는 방식으로 동작한다.
• LLM은 텍스트를 토큰(Token) 단위로 처리하며, 언어에 따라 토큰 사용량과 비용이 달라진다.
• LLM은 컨텍스트 윈도우라는 제한된 단기 기억만 가지고 있어 장기 기억을 위해서는 별도의 시스템 설계가 필요하다. 같은 질문에도 답변이 달라지는 이유는 추론 과정에서 확률적으로 토큰을 선택하기 때문이다.
• AI는 사실 여부를 검증하지 않고 가장 그럴듯한 답을 생성하기 때문에 환각(Hallucination)이 발생할 수 있다.
• 기업에서는 환각 문제를 줄이기 위해 RAG(Retrieval-Augmented Generation)를 활용해 내부 문서나 외부 자료를 참고하도록 한다.
• 에이전트(Agent)는 LLM에 다양한 도구를 연결해 실제 작업을 수행할 수 있도록 확장한 개념이다.
• PM은 AI의 기술적 세부사항을 모두 알 필요는 없지만, 토큰·컨텍스트·추론·RAG·에이전트 정도는 이해해야 올바른 의사결정을 내릴 수 있다.

🔑 주요 키워드 정리

1️⃣ LLM 대규모 언어 모델(LLM)은 방대한 양의 데이터로 사전 학습된 초대형 딥 러닝 모델.

2️⃣ 에이전트 LLM이 단순히 답변하는 것을 넘어 검색, 예약, 이메일 발송 등 실제 행동을 수행할 수 있도록 확장한 구조.

3️⃣ RAG(Retrieval-Augmented Generation) LLM이 답변을 생성하기 전에 관련 문서를 검색하여 참고하도록 하는 기술. 기업용 AI 서비스에서 환각을 줄이는 핵심 방법.

4️⃣ 컨텍스트(Context) LLM이 현재 대화에서 참고할 수 있는 정보 범위. 컨텍스트 한도를 초과하면 이전 내용을 잊어버린 것처럼 동작한다.

💡 나의 생각

이번 기사는 PM을 대상으로 작성된 글이지만, 필자와 같은 주니어 개발자나 개발자를 준비하는 사람들에게도 도움이 되는 내용이라고 생각한다. LLM이라는 개념을 막연히 어렵고 복잡한 기술로만 생각했는데, 대학 시절 ML/DL을 공부하며 접했던 내용들이 실제로 LLM의 동작 원리와 연결되어 있다는 점이 흥미로웠다.

특히 같은 질문에도 서로 다른 답변이 나오는 이유를 설명하는 추론(Inference) 부분이 인상 깊었다. 과거 프로젝트를 진행하면서 항상 가장 높은 정확도의 결과만 선택하는 방식에 한계를 느꼈고, 다양한 후보를 두고 그중에서 선택하는 방식도 고민했던 경험이 있다. 그런데 기사에서 LLM 역시 확률 분포를 기반으로 답을 '계산하는 것'이 아니라 '선택하는 것'에 가깝다는 설명을 보고 반가웠다.

• 알고리즘: DFS/BFS
• 문제 링크: 타겟 넘버

풀이 과정

import java.util.*;

class Solution {

    public int solution(int[] numbers, int target) {

        // return dfs(0, 0, target, numbers);

        return bfs(numbers, target);
    }

    private int dfs(int idx, int sum, int target, int[] numbers) {

        if(idx == numbers.length) {
            return sum == target ? 1 : 0;
        }

        return dfs(idx + 1, sum + numbers[idx], target, numbers)
             + dfs(idx + 1, sum - numbers[idx], target, numbers);
    }

    private int bfs(int[] numbers, int target) {

        int answer = 0;

        Queue<Node> queue = new LinkedList<>();
        queue.offer(new Node(0, 0));

        while(!queue.isEmpty()) {

            Node now = queue.poll();

            if(now.idx == numbers.length) {

                if(now.sum == target) {
                    answer++;
                }

                continue;
            }

            queue.offer(
                new Node(
                    now.idx + 1,
                    now.sum + numbers[now.idx]
                )
            );

            queue.offer(
                new Node(
                    now.idx + 1,
                    now.sum - numbers[now.idx]
                )
            );
        }

        return answer;
    }

    static class Node {
        int idx;
        int sum;

        Node(int idx, int sum) {
            this.idx = idx;
            this.sum = sum;
        }
    }
}

• 문제 핵심:
• DFS는 재귀,깊게 끝까지 파고 넘어가는 걸 이해하기.
• BFS는 Queue로, 순차적으로 넓게 진행 된다는 걸 이해하기.

📌 느낀 점

DFS/BFS 패턴의 감을 익힌다면 쉽게 풀릴것이라 생각한다. 그래서 패턴을 익히기 이전엔 '재귀'와 '큐'를 이해하고 푸는 것이 수월할 것이다.

DFS

DFS(node) ① DFS(Depth-First Search, 깊이우선탐색)는 시작 노드에서 한 방향의 끝까지 탐색 후, 다시 되돌아와 다른 경로를 탐색하는 방식이다.

그래서 다시 돌아오는 형질이 있기 때문에 '스택(Stack)' 자료구조나 '재귀 함수'를 사용해야 한다. 완전 탐색과같은 특징을 파악해야 한다.

BFS

Queue<Integer> queue = new LinkedList<>(); ② BFS (Breadth-First Search, 너비 우선 탐색)는 시작 노드에서 가까운 노드부터 방문하는 넓에 퍼져나가는 탐색 방식이다.

그래서 FIFO 방식인 큐(Queue) 자료구조를 사용해야 한다. 최단 경로를 구할 때 주용 사용된다.

✅ 정점의 수를 V, 간선의 수를 E라고 할 때, 두 알고리즘 모두

• 인접 리스트 방식을 사용하면 O(V+E)
• 인접 행렬 방식을 사용하면 O(V²)

의 시간이 소요된다.

1️⃣ 대표적인 문제

2️⃣ DFS 문제 공식

언제 DFS를 의심할까? 문제에 이런 단어가 보이면 DFS 가능성이 높다.

• 모든 경우의 수
• 가능한 모든 경로
• 조합
• 순열
• 백트래킹

📌 DFS는 크게 2가지로 나뉜다. 1️⃣ 그래프 DFS (네트워크/연결 요소 찾기/트리 탐색)

void dfs(int node){
    visited[node] = true;

    for(int next : graph[node]){
        if(!visited[next]){
            dfs(next);
        }
    }
}

2️⃣ 완전탐색 DFS(타겟 넘버/N-Queen/순열/조합/피로도)

dfs(depth + 1);
dfs(depth + 1);

< DFS 사고 과정 >

✅ STEP 1. 현재 상태 정의 현재 내가 무엇을 탐색하고 있는가?

예)

타겟 넘버 → 현재 인덱스, 현재 합

N-Queen → 현재 행

순열 → 현재 선택 개수

✅ STEP 2. 종료 조건 정의

if(종료조건){
    return;
}

예) if(idx == numbers.length)

✅ STEP 3. 다음 상태 탐색 dfs(다음상태); 가능한 모든 선택지를 재귀 호출한다.

✅ STEP 4. 방문 안 했으면 재귀

if(!visited[next]){
    dfs(next);
}

2️⃣ BFS 문제 공식

언제 BFS를 의심할까? 문제에 이런 단어가 보이면 BFS 가능성이 높다.

• 최단 거리
• 최소 이동 횟수
• 가장 빨리 도착
• 몇 번 만에 도달

Queue<Integer> queue = new LinkedList<>();

queue.offer(start);
visited[start] = true;

while(!queue.isEmpty()){

    int now = queue.poll();

    for(int next : graph[now]){

        if(!visited[next]){

            visited[next] = true;
            queue.offer(next);
        }
    }
}

< BFS 사고 과정>

✅ STEP 1. 시작점 Queue 삽입

queue.offer(start);

✅ STEP 2. 방문 처리

visited[start] = true;

✅ STEP 3. Queue에서 꺼내기

int now = queue.poll();

✅ STEP 4. 다음 노드 확인

for(int next : graph[now])

✅ STEP 5. 방문 안 했으면 Queue 삽입

if(!visited[next]){
    visited[next] = true;
    queue.offer(next);
}

⚠️ DFS/BFS 문제의 핵심

DFS/BFS에서 가장 중요한 것은 중복 방문 방지이다.

이미 방문한 노드를 다시 탐색하면 무한 루프에 빠질 수 있기 때문에 방문 배열을 사용한다.

boolean[] visited = new boolean[n + 1];

혹은

boolean[][] visited = new boolean[n][m];

와 같이 관리한다.

3️⃣ 그리디 알고리즘 문제

• 프로그래머스 DFS/BFS 문제 정리 사이트
• LeetCode LeetCode DFS Problem List LeetCode BFS Problem List

• 알고리즘: 구현 알고리즘
• 문제 링크: 신규 아이디 추천

풀이 과정

import java.util.*;
import java.io.*;

class Solution {
    public String solution(String new_id) {

        return checkId(new_id);
    }

    private String checkId(String new_id) {

        // 1. 대문자 -> 소문자
        new_id = new_id.toLowerCase();

        // 2. 특정 문자 외 특수 문자 제거
        new_id = new_id.replaceAll("[^a-z0-9-_.]","");

        // 3. (.) 2번 이상 연속 -> 1개로 치환
        new_id = new_id.replaceAll("\\.{2,}",".");

        // 4. 처음과 끝이 마침표
        new_id = new_id.replaceAll("^\\.|\\.$","");

        // 5. 빈 문자열
        if(new_id.equals("")){
            new_id = "a";
        }

        // 6. 16자 이상일 경우
        if(new_id.length() > 15){
            new_id = new_id.substring(0, 15);
            new_id = new_id.replaceAll("^\\.|\\.$","");
        }

        // 7. 3자리 이하일 경우
        if(new_id.length() < 3){
            char last = new_id.charAt(new_id.length() - 1);

            while(new_id.length() < 3){
                new_id += last;
            }
        }

        return new_id;
    }
}

• 문제 핵심:
• 자바의 여러가지 함수가 필요함.

📌 느낀 점

문제 자체의 난이도는 높지 않았지만, 평소에 자주 사용하지 않던 문자열 관련 함수와 정규식을 알고 있어야 수월하게 해결할 수 있었다. 특히 replaceAll(), substring(), charAt() 등의 사용법을 다시 정리할 수 있는 문제였다. 알고리즘적인 아이디어보다는 문자열을 조건에 맞게 구현하는 능력이 중요했으며, 관련 함수만 익숙하다면 누구나 충분히 접근할 수 있는 문제라고 느꼈다.

• 제목 : 코드는 AI가 짠다, 책임은 누가 지나
• 출처 : IT WORLD
• 기사 링크 : https://www.itworld.co.kr/article/4177478

📖 기사 핵심 요약

• 실리콘밸리는 SW 개발이 '프롬프트 입력 후 즉시 배포'하는 작업으로 변모하기 직전이라고 외쳐왔다.
• 구글의 신규 코드 중 75%가 이제 AI로 생성되어 엔지니어의 검토를 거치고 있다고 밝혔다.
• 오픈클로를 개발한 엔지니어는 '바이브 슬롭' 범람에 대한 이야기를 했다.
• AI 열풍을 떠받치는 전제를 재점검해야 할 시점이 온 것이다.
• 숙련된 사람에게는 더 많은 일을 더 빠르게 해낼 수 있는 힘을 준다. 반면 미숙하거나 부주의한 사람에게는 더 큰 실수를 더 큰 자신감으로 저지를 수 있는 힘을 준다.
• 진짜 문제는 대규모 언어 모델이 매우 빠르게 그럴듯한 결과물을 생성한다는 점이다. 빠르고 그럴듯한 것은 정확히 프로덕션 환경에 슬그머니 침투하는 종류의 오류다.
• AI는 결과물이 해당 시스템, 보안 모델, 성능 범위, 사용자 요구, 기업 기준에 부합하는지 빠르고 정확하게 판단할 수 있는 사람에게 보상한다.
• AI 슬롭의 추악한 경제학이다. 생성 비용은 저렴하지만 검토 비용은 비싸다.
• 실질적인 질문은 결함이 줄었는지, 납기가 빨라졌는지, 장애가 줄었는지, 고객이 더 만족하는지다.

🔑 주요 키워드 정리

1️⃣ 바이브 슬롭(vibe slop) 생성형 AI 기술이 발전하면서 파생된 두 가지 신조어인 '바이브(Vibe)'와 '슬롭(Slop)'이 결합된 개념.

2️⃣ 슬롭(slop) 인공지능(AI) 기술을 이용해 대량으로 생산되는 저품질의 디지털 콘텐츠를 의미.

3️⃣ 엔터프라이즈 AI 대규모 조직의 비즈니스 과제를 해결하기 위해 기업용 시스템과 데이터에 인공지능을 결합하는 것을 뜻

💡 나의 생각

이번 기사는 AI 활용에 대해 비교적 현실적인 시각을 담고 있다.

특히 인상 깊었던 문장은 “생성 비용은 저렴하지만 검토 비용은 비싸다”는 부분이었다. 실제로 AI는 빠르게 그럴듯한 결과물을 만들어내지만, 그 결과물이 정말 맞는지 검증하는 데에는 오히려 더 많은 시간과 책임이 필요하다. 코드도 마찬가지다. AI가 코드를 작성할 수는 있지만, 그 코드가 보안적으로 안전한지, 기존 시스템과 충돌하지 않는지, 유지보수가 가능한지는 결국 사람이 판단해야 한다.

최근 바이브 코딩이나 노코드 자동화에 관심을 가지며 Zapier 같은 툴을 직접 사용해보면서도 비슷한 점을 느꼈다. 처음에는 AI와 자동화 도구만 있으면 금방 완성될 것처럼 보였지만, 실제로는 흐름 설계와 예외 처리, 검증 단계가 훨씬 중요했다. AI는 빠르게 초안을 만드는 데에는 강하지만, 그 결과물을 실제 서비스 수준으로 끌어올리는 과정에서는 여전히 사람의 경험과 판단이 필요했다.

다만 기사에서 말한 “숙련된 사람에게는 더 많은 생산성을, 미숙한 사람에게는 더 큰 실수를 저지를 힘을 준다”는 문장에서 AI를 제대로 이해하지 못한 상태에서 무분별하게 사용하는 것은 위험할 수 있기에 더 숙련된 사람들이 옆에서 멘토 역할을 해줘야 한다고 생각한다. 예전에도 신입 개발자들은 선배 개발자의 코드 리뷰와 피드백을 통해 성장했듯이, AI 시대에도 결국 중요한 건 협업과 학습 문화라고 느꼈다.

AI는 사람을 완전히 대체하는 존재라기보다는, 잘 이끌어주고 방향을 잡아줄 사람이 있을 때 더 큰 시너지를 낼 수 있는 도구에 가깝다고 생각한다. 그래서 앞으로는 단순히 AI를 잘 쓰는 능력보다도, 다른 사람이 AI를 더 안전하고 효과적으로 활용할 수 있도록 도와주는 역량 역시 중요할 듯 하다.

• 알고리즘: 구현 알고리즘
• 문제 링크: [[프로그래머스 - [카카오 인턴] 키패드 누르기]](https://school.programmers.co.kr/learn/courses/30/lessons/67256)

풀이 과정

class Solution {
    public String solution(int[] numbers, String hand) {
        String answer = "";
        int target = 0; // 눌러야할 키패드
        int[] lefts = new int[]{1, 4, 7};
        int[] rights = new int[]{3, 6, 9};
        int left = 10; // 현재 위치 '*'
        int right = 12; // 현재 위치 '#'

        for(int i = 0; i < numbers.length; i++){
            target = numbers[i];

            if(target == 0) target = 11;

            if(isLeft(target, lefts)){
                answer += 'L';
                left = target;
            } else if(isRight(target, rights)){
                answer += 'R';
                right = target;
            } else { // 거리 계산
                int ifL; int ifR;
                ifL = Math.abs(left - target) / 3 + Math.abs(left - target) % 3;
                ifR = Math.abs(right - target) / 3 + Math.abs(right - target) % 3;

                if(ifR < ifL) {
                    answer += 'R';
                    right = target;
                } else if(ifR > ifL) {
                    answer += 'L';
                    left = target;
                } else { // 거리 같을 때
                    if(hand.equals("right")) {
                        answer += 'R';
                        right = target;
                    } else {
                        answer += 'L';
                        left = target;
                    }

                }
            }
        }
        return answer;
    }

    private boolean isLeft(int target, int[] lefts){

        for(int i = 0; i < lefts.length; i++) {
            if(target == lefts[i]){
                return true;
            }
        }
        return false;
    }

    private boolean isRight(int target, int[] rights){

        for(int i = 0; i < rights.length; i++) {
            if(target == rights[i]){
                return true;
            }

        }
        return false;
    }

}

• 문제 핵심:
• 함수를 따로 만들어 left/right 키패드 분리
• 거리 계산은 (절대값 / 3 ) + (절대값 % 3)
• 이때 절대값은 '왼쪽, 오른쪽 손가락 위치 - 타겟 위치'

📌 느낀 점

역시 구현 알고리즘은 코드는 길어질지라도 내가 생각한 대로만 코드를 짜면 어느정도 풀리는 것 같다. 그러나 단순히 코드만 작성하는 것이 아닌 어느정도의 논리적인 부분도 필요하다. 위의 문제인 경우 키패드는 3열 4행이니까 /와 %를 이용해야 거리를 계산할 수 있다.

• 제목 : 바이브 코더 11명과 함께 사내 플랫폼 만들어봤습니다
• 출처 : 요즘 IT
• 기사 링크 : https://yozm.wishket.com/magazine/detail/3758/

📖 기사 핵심 요약

• AI에게 중요한 건 똑똑함이 아니라 맥락이다.
• 개발자들은 그 맥락을 어떻게 안저적으로 전달할 수 있을지 설계한다.
• AI 대화 세션이 하나 열릴 때마다 서버 안에서 해당 프로젝트의 코드베이스를 통째로 복제했다.
• 글의 핵심 메시지는 “개발자의 역할이 코드를 작성하는 사람에서, AI와 사람이 함께 일할 환경을 설계하는 사람으로 이동하고 있다”는 점이다.

🔑 주요 키워드 정리

1️⃣ 바이브 코딩 (Vibe Coding) AI와 자연어 기반으로 대화하며 서비스를 구현하는 개발 방식. 비개발자도 기능 제작에 참여할 수 있다는 특징이 있다.

2️⃣ 가드레일 (Guardrail) AI와 사용자가 실수하더라도 전체 시스템이 망가지지 않도록 제한과 검증 장치를 두는 개념. E2E 테스트와 격리된 작업 환경이 대표 사례로 소개됐다.

3️⃣ E2E End-to-End(엔드투엔드)의 약자로, ‘처음부터 끝까지’, ‘시작점부터 종착점까지’의 전체 과정을 의미.

4️⃣ 플랫폼 사고(Platform Thinking) 한 사람을 돕는 것이 아니라, 여러 사람이 동시에 서비스를 만들 수 있는 기반 자체를 만드는 사고방식.

💡 나의 생각

예전에는 AI를 잘 활용한다는 것이 단순히 “프롬프트를 잘 작성하는 것”이라고 생각했다. 하지만 이 글을 읽고 나서는 AI를 잘 활용하는 사람은 결국 “AI가 일할 수 있는 환경 자체를 설계하는 사람”이라는 생각이 들었다.

특히 인상 깊었던 부분은 AI에게 계속 더 좋은 답변을 요구한 것이 아니라, AI가 참고할 공통 문서와 규칙을 만들었다는 점이었다. design-system, docs, 스키마 문서화 같은 작업은 사람 입장에서는 귀찮고 반복적인 정리처럼 보일 수 있지만, AI에게는 정확한 맥락을 제공하는 핵심 장치였다. 결국 AI의 성능 차이는 모델 자체보다도 어떤 컨텍스트를 주느냐에서 나온다는 걸 다시 느꼈다.

무엇보다 가장 흥미로웠던 건 개발자의 역할 변화에 대한 부분이다. 예전에는 개발자의 핵심 역량이 “얼마나 빠르고 정확하게 코드를 작성하느냐”에 있었다면, 이제는 “AI와 사람이 함께 일할 수 있는 판을 얼마나 잘 설계하느냐”로 이동하고 있다는 느낌을 받았다.

• 제목 : 12분 49초 만에 한 달치 기획이 나왔다: 콘텐츠 AX 실험기
• 출처 : 요즘 IT
• 기사 링크 : https://yozm.wishket.com/magazine/detail/3647/

📖 기사 핵심 요약

• AI에게 한 번에 모든 작업을 맡기기보다, 리서치·기획·글쓰기·검수를 역할별 에이전트로 분리했을 때 더 높은 품질의 결과물이 나왔다.
• AI 검색 시대에는 “AI에게 잘 읽히는 콘텐츠”의 중요성이 커지고 있다고 분석했다.
• 슬랙 명령어 하나만으로 한 달치 콘텐츠 기획안과 제목, H2 구조, CTA까지 자동 생성되는 시스템을 구축했다.
• 결국 자동화는 단순히 “AI가 글을 써주는 것”이 아니라, 사람의 업무 과정을 어떻게 구조화하고 분리할 것인지의 문제라고 설명한다.

🔑 주요 키워드 정리

1️⃣ GEO(Generative Engine Optimization) ChatGPT, Gemini, Perplexity 같은 생성형 AI 검색 엔진이 콘텐츠를 더 잘 인용하고 활용할 수 있도록 구조화하는 최적화 방식

2️⃣ 콘텐츠 자동화 파이프라인(Content Automation Pipeline) 콘텐츠 기획, 생성, 검수, 발행, 뉴스레터 변환 등을 단계별로 자동화하는 시스템 구조

3️⃣ AI 에이전트(AI Agent) 특정 역할과 목적을 가지고 독립적으로 작업을 수행하는 AI 시스템. 리서치, 기획, 작성 등 역할을 분리해 협업 가능

4️⃣ Trigger–Condition–Action(T–C–A) 자동화의 기본 구조로, 특정 이벤트(Trigger)가 발생하면 조건(Condition)을 검사한 뒤 작업(Action)을 수행하는 방식

5️⃣ 프롬프트 엔지니어링(Prompt Engineering) AI에게 원하는 결과를 얻기 위해 작업 맥락, 역할, 조건 등을 구조적으로 설계하는 과정

💡 나의 생각

최근 노코드와 자동화에 관심이 생겨 직접 Zapier를 이용해 뉴스 리뷰 요약을 Google Docs에 자동 삽입하는 실습을 해보았다. 그래서 처음에는 이 글도 단순히 Zapier, Make, n8n, Dify 같은 자동화 툴들의 차이점을 설명하는 글이라고 생각했다.

하지만 실제로는 “자동화를 어떻게 설계해야 하는가”에 대한 이야기였다는 점이 인상 깊었다. 자동화는 단순히 툴을 연결하는 작업이 아니라, 사람이 반복적으로 수행하던 업무를 어떻게 분리하고 구조화할 것인지에 대한 설계 과정이라는 걸 느꼈다.

특히 가장 흥미로웠던 부분은 AI에게 한 번에 모든 작업을 맡기지 않고, 리서처 에이전트와 플래너 에이전트처럼 역할을 나눠 단계별로 처리했다는 점이었다. 처음에는 AI가 한 번에 다 처리할수록 더 효율적일 거라고 생각했는데, 오히려 작업을 세분화할수록 결과물의 품질과 신뢰도가 높아진다는 점이 새롭게 다가왔다.

또한 이 글을 통해 AI 자동화에서 중요한 것은 단순한 개발 능력이 아니라, “업무 흐름을 이해하고 기획할 수 있는 능력”이라는 생각도 들었다. 결국 AI도 사람이 어떤 맥락과 목표를 주느냐에 따라 결과가 완전히 달라지기 때문이다.

앞으로는 단순히 코드를 잘 작성하는 개발자보다, 반복 업무를 구조적으로 분석하고 AI에게 적절히 역할을 위임할 수 있는 사람이 더 중요한 역량을 가지게 될 것 같다고 느꼈다.

• 제목 : Zapier vs Make vs n8n 보다 미리 알아야 할 것들
• 출처 : 요즘 IT
• 기사 링크 : https://yozm.wishket.com/magazine/detail/3580/

📖 기사 핵심 요약

• 자동화는 툴 고르기가 아닌 업무 흐름에서 반복 작업을 분리해 위임하는 설계의 문제다.
• 업무에서 줄여야 할 반복이 어디에 숨어있나 찾는 일부터 시작해야 한다.
• 툴은 수단인데, 수단이 목적을 끌고 가는 순간 실패 확률이 올라간다.
• 업무 자동화는 분리 -> 표준화 -> 위임 프레임으로 보는 것이 좋다.
• 자동화 툴들은 대부분 같은 문법을 따른다. [트리거 - 조건 - 액션] 구조
  • "만약 [트리거]가 발생하면, [조건]을 검색해서, 맞으면 [액션]을 실행한다".
• 업무 흐름을 이 단계로 잘 나누면 사람이 손으로 넘기는 지점이 나타나고, 자동화는 보통 그 지점에 들어갈 때 가장 큰 효과가 나며, 사람이 시스템 사이를 오가는 순간을 찾아 대체하는 느낌이다.
• 거창한 설계는 실패의 지름길이다.
• 첫 자동화는 끝까지 목표로 하지 않는 게 안전하다.
• 자동화의 목적을 자주 점검해야 한다.(리드타임을 줄이고, 누락을 막고, 중복 없애기)
• 현업에서는 돌아가긴 하는데 불안한 자동화가 가장 위험하다. (권한/보안, 책임 소재)

[Zapier]

• 분기가 적을수록 속도가 난다. 연결을 빠르게 해서 도입 초반엔 일단 돌아가게 하는데 강하다.
• 복잡한 설계보다 실행이 먼저인 팀에 잘 맞는다.
• 다만 조건이 늘고 시나리오가 커질수록 관리가 어렵다. [Make]
• 한 번의 트리거에서 여러 액션으로 뻗는 형태에 유리하다.
• 시각화는 처음에는 좋지만, 복잡해지면 오히려 어디에 손을 대야하나 싶은 감각을 주기도 한다. [n8n]
• 사내 시스템 연동 같은 케이스에 적합하다.
• 커스터마이징에 초점이 맞춰진 도구다.
• 코드 기반 처리를 할 수 있다.
• 통제권을 온전히 쥐는 자동화에 적합하다.
• 입문에 난이도가 있다. [Dify]
• 생각하는 단계에 맡기는 도구에 가깝다.
• n8n보다 조금 더 난이도가 있다.

🔑 주요 키워드 정리

1️⃣ 업무 자동화(Workflow Automation) 반복적으로 수행되는 업무를 시스템이나 소프트웨어가 대신 수행하도록 만드는 과정이다.

2️⃣ Trigger–Condition–Action(T–C–A) 자동화의 기본 구조이다. Trigger(시작 조건) → Condition(실행 조건 판단) → Action(실제 수행) 순서로 동작한다.

💡 나의 생각

요근래 노코드의 개념부터 직접 실습까지 해보자는 생각으로, 최근에는 Zapier를 활용해 뉴스 리뷰 요약 내용을 Google Docs에 자동으로 삽입하는 자동화 흐름을 만들어보고 있다. 그래서 이 기사를 처음 봤을 때만 해도 단순히 Zapier, Make, n8n 같은 자동화 툴들의 차이점과 특징을 비교해주는 글이라고 생각했다.

하지만 글을 읽으면서 느낀 건, 자동화의 핵심은 “어떤 툴을 쓰느냐”보다 “어떤 업무를 어떻게 분리하고 설계하느냐”에 더 가깝다는 점이었다. 특히 반복되는 업무를 단순히 줄이는 것이 아니라, 업무 흐름 속에서 반복성과 규칙성을 찾아 시스템에 위임하는 과정이라는 설명이 인상 깊었다.

또한 Trigger–Condition–Action(T–C–A) 구조로 자동화를 바라보는 방식도 굉장히 실무적이라고 느꼈다. 예를 들어 내가 하고 있는 뉴스 리뷰 자동화 역시:

Trigger: 새로운 뉴스 리뷰 작성 Condition: 특정 키워드 또는 형식 만족 Action: Google Docs에 자동 저장

처럼 구조화할 수 있다는 점에서 자동화를 조금 더 체계적으로 이해하게 되었다.

특히 인상 깊었던 부분은 “자동화는 사람을 완전히 대체하는 것이 아니라, 사람이 반복적으로 하던 전달·복사·확인 같은 작업을 시스템에 위임하는 설계”라는 관점이었다. 이전에는 자동화를 단순히 편리한 기능 정도로 생각했는데, 이제는 업무 흐름 자체를 분석하고 병목을 찾아내는 사고방식이 더 중요하다는 걸 느꼈다.

툴 비교 부분도 흥미로웠다. Zapier는 빠르고 단순한 연결에 강하고, Make는 복잡한 흐름 설계, n8n은 높은 자유도와 자체 호스팅, Dify는 AI 기반 판단과 분류에 강점이 있다는 점에서 각각의 역할이 명확하게 다르다는 걸 알게 되었다. 결국 “어떤 툴이 최고인가”가 아니라, “현재 내 업무의 병목이 무엇인가”에 따라 선택해야 한다는 점도 공감됐다.

앞으로는 단순히 AI나 자동화 툴을 사용하는 수준을 넘어, 반복 업무를 구조적으로 바라보고 이를 효율적으로 위임할 수 있는 설계 능력이 더 중요해질 것 같다. 나 역시 작은 자동화부터 직접 만들어보면서, 단순 사용자가 아니라 업무 흐름을 설계할 수 있는 개발자로 성장해보고 싶다는 생각이 들었다.

• 알고리즘: 구현 알고리즘
• 문제 링크: 프로그래머스 - 실패율

풀이 과정

import java.util.*;

class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];

        HashMap<Integer, Double> map = new HashMap<>(); // 스테이지 번호, 실패율

        int users = stages.length; // 총 참여 인원
        double rate = 0; // 실패율

        for(int i = 1; i <= N; i++){

            int count = 0; // 실패자 카운트

            for(int j = 0; j < stages.length; j++){

                // ex) 1번 스테이지(N) 다 돌며 1번 실패자 찾기.
                if(i == stages[j]){
                    count++;
                }
            }

            if(users == 0) {
                rate = 0;
            } else {
                rate = (double) count / users;
            }

            map.put(i, rate);

            users = users - count;
        }

        // 실패율 정렬(내림차)
        List<Map.Entry<Integer, Double>> list =
                new ArrayList<>(map.entrySet());

        list.sort(Map.Entry.<Integer, Double>comparingByValue().reversed());

        for(int i = 0; i < N; i++){
            answer[i] = list.get(i).getKey();
        }

        return answer;
    }
}

• 문제 핵심:
• HashMap을 이용해 stage 마다 실패율 저장.
• 현재 스테이지에 머물러 있는 사람 수(count)를 이용해 실패율 계산.
• 스테이지를 순회하면서 이전 스테이지 실패 인원을 제외하기 위해 users -= count 처리.
• Map.Entry와 comparingByValue()를 사용하여 실패율 기준 내림차순 정렬.

📌 정렬 핵심 (Map.Entry)

HashMap = 저장용
List<Entry> = 정렬용 변환 구조
Comparator = 정렬 기준
-------------------------------------------------------------------------
✔ comparingByValue()
- value 기준 정렬
- 기본은 오름차순
✔ reversed()
- 정렬 방향 반전 → 내림차순
- list.sort(Map.Entry.<Integer, Double>comparingByValue().reversed());
    ☞ 실패율 높은 순으로 정렬

+추가 정리 ✔ comparingByKey() key 기준 정렬 가능 스테이지 번호 기준 정렬할 때 사용

📌 느낀 점

처음에는 문제 설명이 직관적으로 와닿지 않아 혼란이 있었지만, “현재 스테이지 = 아직 클리어하지 못한 위치”라는 구조를 이해한 뒤 풀이 방향이 명확해졌다.

구현 알고리즘은 머릿속에 있는 문제 해결 과정을 코드로 정확하게 표현하는 문제 유형이다. 그래서 논리적으로는 이해가 가지만 코드로 작성하게 되면 길어지는 경우가 있다.

즉, 복잡한 아이디어보다는 조건에 맞게 하나씩 그대로 작성하는 능력이 중요하다.

대표적으로는 다음과 같은 상황에서 사용된다.

문자열 처리 시뮬레이션 문제 좌표 이동 문제 배열 회전 문제

1️⃣ 대표적인 문제

🕹️ 상하좌우 문제

N x N 크기의 공간에서 사용자의 이동 계획에 따라 위치를 이동하는 문제

이동 가능한 방향:

L : 왼쪽 R : 오른쪽 U : 위 D : 아래

<풀이 핵심> : 이동 방향에 따라 좌표를 직접 변경한다.

int n = 5;

String[] move = {"R", "R", "R", "U", "D", "D"};

int x = 1;
int y = 1;

for(String dir : move){

    if(dir.equals("L") && y > 1){
        y--;
    }

    else if(dir.equals("R") && y < n){
        y++;
    }

    else if(dir.equals("U") && x > 1){
        x--;
    }

    else if(dir.equals("D") && x < n){
        x++;
    }
}

System.out.println(x + " " + y);

2️⃣ 그리디 알고리즘 문제 공식

구현 문제를 보면 보통 아래 흐름으로 접근한다.

✅ STEP 1. 문제 조건 정리하기 ex)

• 무엇을 이동하는가?
• 무엇을 출력해야 하는가?
• 예외 조건은 무엇인가?

✅ STEP 2. 변수와 상태 정의하기

현재 위치, 방향, 시간, 배열 상태 등을 변수로 저장한다.

예시:

좌표(x, y) 방향(dx, dy) 시간(time) 방문 여부(boolean)

✅ STEP 3. 조건대로 그대로 코드 작성하기

구현 문제는 알고리즘 아이디어보다 “문제에서 하라는 것을 정확하게 구현”하는 것이 핵심이다.

반복문과 조건문을 이용해 문제 흐름을 차근차근 코드로 옮긴다.

구현 문제는 문제 조건을 꼼꼼히 읽고 직접 흐름을 따라가는 연습이 핵심이다

3️⃣ 구현 알고리즘 문제

• 프로그래머스
  • 시뮬레이션 기둥과 보 설치
  • 문자열 구현: 문자열을 직접 하나씩 처리하는 문제 문자열 압축 신규 아이디 추천
  • 완전탐색 + 구현: 모든 경우를 직접 구현해서 검사 모의고사 체육복
  • 배열 구현(2차원) 키패드 누르기 프렌즈4블록
  • 조건 처리 구현 비밀지도 실패율

• 알고리즘: 그리디 알고리즘
• 문제 링크: 프로그래머스 - 구명보트

풀이 과정

import java.util.*;

class Solution {
    public int solution(int[] people, int limit) {
        Arrays.sort(people);

        int left = 0; // 가장 가벼운 사람
        int right = people.length - 1; // 가장 무거운 사람
        int answer = 0;

        while(left <= right) {
            if(people[left] + people[right] <= limit) {
                left++;
            }
            right--;
            answer++;
        }


        return answer;
    }
}

• 문제 핵심: 가장 무거운 사람 기준으로 생각하기.
• 투포인터를 이용해 턴 마다 가장 무거운 사람을 무조건 태워 보내야 한다는 개념으로 코드 설계

• 알고리즘: 그리디 알고리즘
• 문제 링크: 프로그래머스 - 조이스틱

풀이 과정

class Solution {
    public int solution(String name) {
        int answer = 0;

        // 좌우 이동 최소값
        int move = name.length() - 1;

        for(int i = 0; i < name.length(); i++) {
            char c = name.charAt(i);

            // 위/아래 이동 계산
            answer += Math.min(c - 'A', 'Z' - c + 1);

            int next = i + 1;

            while(next < name.length() && name.charAt(next) == 'A') next++;

            // 좌우 이동 최소값 갱신(예: AAAABBA)
            move = Math.min(move, i+name.length() - next + Math.min(i, name.length() - next));
        }

        answer += move;

        return answer;
    }
}

[핵심코드]

• 위/아래 조작(알파뱃 조작)

  • Math.min(c-'A', 'Z'-c+1)
    • c - 'A': 위로 이동 (A → B 방향)
    • 'Z' - c + 1: 아래로 이동 (A → Z 방향)

• while문의 역할: 연속된 A 구간의 끝 위치(next) 찾기

• 커서 이동 최소화

  move = Math.min(
      move,
      i + name.length() - next + Math.min(i, name.length() - next)
  );

  • name.length() - next 뒤쪽 남은 거리
  • Math.min(i, name.length() - next) 방향 전환 비용 최소 선택

• 알고리즘: 그리디 알고리즘
• 문제 링크: 프로그래머스 - 체육복

풀이 과정

import java.util.*;

class Solution {
    public int solution(int n, int[] lost, int[] reserve) {
        int answer = 0;

        int[] clothes = new int[n+2]; // 배열 범위 에러 방지 & 1부터 시작하기 위함

        Arrays.fill(clothes, 1);

        for(int l : lost) {
            clothes[l]--;
        }

        for(int r : reserve){
            clothes[r]++;
        }

        // 빌려주기
        for(int i = 1; i<=n; i++){
            if(clothes[i]==0) {
                if(clothes[i-1] == 2) {
                    clothes[i-1]--;
                    clothes[i]++;
                }
                else if(clothes[i+1] == 2) {
                    clothes[i+1]--;
                    clothes[i]++;
                }
            }
        }

        for(int i = 1; i<=n; i++) {
            if(clothes[i]>=1){
                answer++;
            }
        }

        return answer;
    }
}

• int[] clothes = new int[n+2]; → n+2를 함으로써 배열을 1부터 시작하게 한다 & 배열 범위 초과 에러를 방지한다.
• for문 + if문을 통해 앞/뒤 학생에게 빌릴 수 있다.

그리디 알고리즘(Greedy Algorithm)은 현재 상황에서 가장 최선이라고 생각되는 선택을 반복하는 알고리즘이다.

즉, 미래를 미리 고려하기보다 “지금 당장 가장 좋은 선택”을 계속 고르는 방식이다.

대표적으로는 다음과 같은 상황에서 사용된다.

동전 거스름돈 문제 회의실 배정 문제 최소 비용 계산 문제

1️⃣ 대표적인 문제

💰 거스름돈 문제

거스름돈이 1260원일 때 500원, 100원, 50원, 10원 동전을 사용하여 최소 개수의 동전으로 거슬러 주기

<풀이 핵심> : 가장 큰 동전부터 최대한 사용한다.

int[] coins = {500, 100, 50, 10};
int money = 1260;
int count = 0;

for (int coin : coins) {
    count += money / coin;
    money %= coin;
}

System.out.println(count);

2️⃣ 그리디 알고리즘 문제 공식

그리디 문제를 보면 보통 아래 흐름으로 접근한다.

✅ STEP 1. 기준 정하기

무엇을 우선 선택할 것인가?

• 가장 큰 값
• 가장 작은 값
• 가장 빠른 시간
• 가장 적은 비용

✅ STEP 2. 정렬하기

그리디 문제는 대부분 정렬이 핵심이다.

Arrays.sort(arr); 혹은 Comparator를 사용해 기준 정렬을 한다.

✅ STEP 3. 현재 최선 선택 반복

반복문을 돌며 현재 기준에서 가장 좋은 선택을 계속 수행한다.

⚠️ 그리디 알고리즘의 함정 "현재 최선의 선택"이 "전체 최적의 선택"을 보장해야 한다.

예를 들어 특정 동전 구조에서는 큰 동전부터 선택하면 오히려 비효율적일 수 있다.

따라서 규칙성이 있는가? 현재 선택이 미래에도 영향을 주지 않는가? 를 확인해야 한다.

3️⃣ 그리디 알고리즘 문제

• 프로그래머스 Greedy 문제 정리 사이트
• LeetCode LeetCode Greedy Problem List Greedy 문제 정리 사이트

• 제목 : “소프트웨어는 더 배고파질 것” AI 시대에도 개발자는 사라지지 않아
• 출처 : IT World
• 기사 링크 : https://www.itworld.co.kr/article/4168148

📖 기사 핵심 요약

• 과거에는 개발 리소스 부족으로 구현하지 못했던 아이디어들도 AI를 통해 빠르게 프로토타입화할 수 있게 되었다.
• AI가 만든 코드를 실제 서비스 환경에서 안전하고 효율적인지 판단 하는 책임은 사람에게 있다.
• 좋은 코드를 작성하는 능력과 AI 에이전트가 좋은 코드를 작성하도록 하는 능력은 다르지만 연관된 기술이다.

💡 나의 생각

이번 기사는 "AI가 코드를 대신 작성하면 개발자는 줄어드는 것 아닐까?"라는 흔한 생각과는 반대의 관점을 보여줘서 흥미로웠다. 오히려 AI 때문에 더 많은 소프트웨어와 서비스가 만들어질 수 있다는 점이 인상적이었다.

실제로 요즘은 아이디어만 있어도 AI를 활용해 빠르게 프로토타입을 만들 수 있는 시대가 되어가고 있다. 예전에는 개발 인력이나 시간 부족으로 구현하지 못했던 기능들도 이제는 훨씬 빠르게 시도할 수 있게 되었다. 나 역시 개인 프로젝트를 진행하면서 생성형 AI나 바이브 코딩 도구를 활용해본 경험이 있어서 기사 내용이 더욱 현실적으로 느껴졌다.

하지만 기사에서 말한 것처럼, AI가 코드를 작성해준다고 해서 개발자의 역할이 사라지는 것은 아니라고 생각한다. 오히려 AI가 만든 결과물을 이해하고, 왜 그렇게 동작하는지 검증할 수 있는 능력이 더 중요해지고 있다는 점에 공감했다.

특히 AI가 작성한 코드는 얼핏 보면 잘 동작해 보이지만, 보안이나 구조적인 문제까지 완벽하게 고려하지 못하는 경우도 많다. 최근 바이브 코딩 관련 보안 사고 사례들을 보면서도 느꼈지만, 결국 중요한 것은 "코드를 얼마나 빨리 만드는가"보다 "그 코드를 제대로 이해하고 책임질 수 있는가"라는 생각이 들었다.

• 제목 : 16년 된 백준(BOJ)이 문을 닫습니다
• 출처 : 요즘 IT
• 기사 링크 : https://yozm.wishket.com/magazine/detail/3712/

📖 기사 핵심 요약

• #1 Claude Code Routines 출시
  • 스케줄 / GitHub 이벤트 / API 호출을 기준으로 자동 실행되는 기능이다.
  • 노트북을 꺼도 Anthropic 클라우드에서 계속 작업이 진행된다.
  • PR 리뷰, 이슈 분류, 문서 업데이트, 알림 분석 등 반복 업무 자동화에 활용 가능하다. 단, 완전 자율 모드이기 때문에 권한 관리와 연결된 서비스 범위 설정이 중요하다.
• #2 백준(BOJ) 서비스 종료
  • 문제 데이터와 제출 기록은 보존되며, 일부 형태로 재개 가능성도 열어두었다.
  • 커뮤니티에서는 코딩 테스트 문화와 알고리즘 평가 방식에 대한 다양한 의견이 나오고 있다.
• #3 AI로 만든 환자 관리 앱, 30분 만에 해킹
  • 전체 환자 데이터가 인터넷에 암호화 없이 노출되어 있었다
  • 기능 구현은 되었지만, 보안·아키텍처·법적 책임에 대한 이해 부족이 핵심 문제였다.

🔑 주요 키워드 정리

1️⃣ AI Agent Automation AI가 사람이 지시할 때만 움직이는 것이 아니라, 이벤트 발생 시 자동으로 반복 업무를 수행하는 방식

2️⃣ 서버 사이드 보안 클라이언트가 아닌 서버에서 인증·인가를 수행하는 안전한 구조

💡 나의 생각

사실 이번 기사는 제목을 보고 자연스럽게 클릭하게 되었다. ‘백준’이라는 이름은 개발자라면 한 번쯤은 반드시 들어봤고, 많은 취업 준비생들이 거쳐 갔던 상징적인 플랫폼이기 때문이다. 그런 백준이 서비스를 종료한다는 소식은 개인적으로 꽤 크게 다가왔다. 마치 예전에 익숙했던 쥬니버네이버가 사라지는 듯한 아쉬움과 비슷한 느낌이었다.

하지만 내용을 읽어보니, 단순히 백준 종료 소식을 전하는 기사가 아니라 AI 시대에 개발자가 어떤 역량을 가져야 하는지 보여주는 기사라는 생각이 들었다.

먼저 Claude Code Routines 사례를 보며, AI가 단순히 코드를 생성하는 도구를 넘어 실제 업무를 자동화하는 단계까지 발전하고 있다는 점이 인상적이었다. 반복적인 PR 리뷰, 이슈 정리, 알림 분류 같은 작업을 AI가 대신 수행하는 시대가 이미 시작된 것이다. 만약 앞으로 회사에 입사하게 된다면, 이러한 기능을 실제 업무에서 적극적으로 활용하게 되지 않을까 상상해보게 되었다. 앞으로 개발자는 단순히 직접 코드를 작성하는 사람보다, AI에게 어떤 업무를 맡기고 어떻게 관리할지 설계할 수 있는 사람이 더 중요해질 것 같다.

또한 백준 서비스 종료 소식은 취업 준비생 입장에서 가장 크게 와닿았다. 개발자 성장 과정에서 백준은 단순한 문제 풀이 사이트가 아니라, 실력을 키우고 성취감을 얻던 상징적인 공간이었기 때문이다. 동시에 시대가 변화하면서 알고리즘 문제 풀이만으로 개발자의 역량을 평가하기는 점점 어려워지고 있다는 흐름도 느껴졌다.

마지막으로 환자 관리 앱 사례는 특히 강렬했다. AI가 코드를 빠르게 만들어줄 수는 있지만, 그 코드가 왜 안전한지 판단하고 책임지는 역할은 결국 사람에게 있다는 사실을 보여주었다. 기능 구현 능력만큼이나 구조 이해력, 보안 감수성, 데이터 책임 의식이 중요해지는 시대라는 생각이 들었다.

결국 앞으로 개발자는 코드를 많이 작성하는 사람보다, AI가 만든 결과물을 검증하고 책임질 수 있는 사람이 더 큰 경쟁력을 갖게 될 것이라고 느꼈다.

• 제목 : 네이버, 연관 검색어·클로바X 접고 AI 검색·에이전트에 총력
• 출처 : AI TIMES
• 기사 링크 : https://www.aitimes.com/news/articleView.html?idxno=208901

📖 기사 핵심 요약

1. 네이버가 약 20년간 운영해오던 ‘연관 검색어’ 서비스를 종료한다. → 전통 검색 UI를 버리고 AI 검색 경험 중심으로 전환하는 전략 때문.
2. 네이버는 기존 검색 기능 대신 AI 브리핑 기능을 강화하고 있다. → 현재 전체 검색 질의 중 약 20%가 AI 브리핑 적용.
3. 챗봇형 서비스인 클로바X, 검색형 AI 서비스 큐(Cue:) 역시 단계적으로 종료될 예정.
4. 네이버는 단순 검색 엔진이 아니라 정보 탐색 → 쇼핑 → 실행까지 이어지는 AI 에이전트 기반 사용자 경험을 구상 중.
5. 이를 위해 올해 상반기 중 네이버 앱에 ‘AI 탭’을 신설하며, 검색의 중심 패러다임 전환을 준비 중.
6. 글로벌 빅테크와의 경쟁 속에서 검색 중심 네이버 → AI 중심 네이버로 체질 전환을 하고 있다는 평가가 나온다.

💡 나의 생각

이번 기사에서 가장 인상적이었던 점은, 네이버가 기존의 ‘검색 서비스’를 유지하기보다 AI 중심으로 패러다임을 완전히 바꾸고 있다는 결정이었다. 특히 20년 넘게 이어져 온 ‘연관 검색어’를 종료한다는 건 단순한 서비스 변화가 아니라, 네이버 자체의 정체성이 바뀌고 있다는 의미처럼 느껴졌다.

네이버가 강조하는 ‘AI 브리핑’은 이미 적지 않은 사용자에게 적용되고 있고, 앞으로는 검색 결과도 점점 AI가 직접 정리하고 제시하는 방식으로 이동할 것 같다.

• 제목 : “AI 에이전트끼리만 소통”… 몰트북·오픈클로가 드러낸 보안 경고
• 출처 : IT 조선
• 기사 링크 : https://it.chosun.com/news/articleView.html?

📖 기사 핵심 요약

1. 몰트북·오픈클로 개요

• AI SNS 몰트북(Moltbook)은 보안 취약점으로 보안 업계의 경고를 받고 있음
• Clawdbot → Moltbot → OpenClaw로 이름이 변경됨
• 오픈클로(OpenClaw)는 MCP 기반의 ‘다중 AI 에이전트 운용 프레임워크’
• 몰트북 내 AI 에이전트는 기술·경제 요약, 철학 토론, 잡담까지 다양한 콘텐츠 생성
• SNS·생성형 AI 서비스 API 키를 연동해 에이전트가 활용 가능
• 기능은 혁신적이지만 보안 평가는 ‘최악’으로 분류됨

2. 근본적 구조적 위험

• 민감 정보 접근 + 신뢰 불가능한 외부 입력이 결합된 구조
• 이메일, 문서, 메시지, 파일 등의 민감한 정보 접근 가능
• 웹 게시물·SNS 글처럼 위험한 외부 입력을 그대로 받음 → 구조적으로 근본적인 위험 요인
• 핵심 위협: 프롬프트 인젝션(prompt injection)
• 코드 취약점 없이 텍스트만으로 공격 가능
• 기존 보안 솔루션으로 탐지가 어려움

3. 보안 테스트 결과와 실증 사례

• 프롬프트 인젝션 성공률 91.3%
• 제로리크스 보안 점수 100점 중 2점
• 개발자들이 Slack·Notion·Google 등 API 키를 동시에 연동 중 → 연쇄적 권한 오남용 가능성
• 몰트북 운영 중 DB 접근 제어 미비로 토큰이 외부에서 접근 가능했던 사례 존재

4. 보안 업계 우려와 앞으로의 방향성

• AI 판단 취약점 + 자동화된 행동 권한이 결합될 때의 피해를 경고
• 정보 오류를 넘어서 [정보 유출, 시스템 오작동, 의도하지 않은 외부 전송] → 실제 피해로 이어질 위험
• 향후 핵심 과제는 ‘구조적 보안 설계’ AI가 어떤 입력을 받고 어떤 행동을 할 수 있는지 → 시스템 수준에서 제한하는 것이 필수적

🔑 주요 키워드 정리

1️⃣ MCP(Model Context Protocol) AI 모델(LLM)이 데이터베이스, 파일 시스템, 외부 API 등 다양한 외부 도구 및 데이터 소스와 일관되고 표준화된 방식으로 소통할 수 있게 해주는 오픈 소스 프로토콜

2️⃣ 프롬프트 인젝션(prompt injection) 생성형 AI(LLM)에게 악의적인 명령어를 입력하여 기존의 보안 지침이나 프롬프트를 무시하고, AI가 의도치 않은 동작을 하도록 유도하는 보안 공격 기법

3️⃣ 시스템 프롬프트 추출(System Prompt Extraction) 거대 언어 모델(LLM) 기반의 챗봇이나 AI 에이전트가 내부적으로 숨겨두고 사용하는 ‘시스템 지침(System Prompt)’을 사용자가 인위적으로 유도하여 외부로 노출시키는 행위

💡 나의 생각

이 기사는 ‘기술 혁신의 속도’가 ‘보안 체계의 발전 속도’를 초월해버린 대표적인 사례라는 점을 잘 보여준다. 특히 오픈클로 사태를 통해, AI 기술이 얼마나 빠르게 확산되는지, 그리고 그 속도에 비해 보안적 대응은 아직 매우 미흡하다는 사실을 다시금 실감했다.

나는 그동안 보안은 결국 “코드의 취약점”을 통해 뚫리는 것이라고만 막연히 생각해왔다. 그런데 기사에서는 AI 프롬프트를 이용한 지시만으로도 충분히 취약성을 공격할 수 있다는 점을 보여주었고, 이 부분이 개인적으로 가장 충격적이었다. 즉, 더 이상 복잡한 해킹 기술이 아니라, 자연어로 이루어진 ‘명령’ 자체가 공격 벡터가되는 시대가 열린 것이다. 그래서 앞으로는 AI에게 너무 많은 개인 정보를 넘기지 않는 등, 일상 속에서도 보안 감수성을 더 높여야겠다고 느꼈다.

특히 오픈클로 환경 테스트에서 프롬프트 인젝션 성공률이 91%에 달했다는 점은 현재의 AI 보안 수준이 얼마나 취약한지를 잘 보여준다. 기술이 고도화되고 활용 범위가 넓어졌지만, 그만큼 안전장치와 통제 장치가 따라오지 못하고 있는 것이다. 앞으로는 단순히 기술 발전만 바라보는 것이 아니라, AI 기반 서비스들이 갖는 보안 취약성을 제대로 인지하고 대비하는 태도가 개인·기업 모두에게 필수적이라는 점을 다시 느끼게 해준 기사였다.

• 제목 : [CISO 조찬] 이원태 교수 “AI 3강, 보안 없이 불가능”…한국형 AI 보안정책 전환 필요성 강조
• 출처 : 데일리시큐
• 기사 링크 : https://www.dailysecu.com/news/articleView.html?idxno=205963

📖 기사 핵심 요약

1. AI 시대 보안 정책의 필요성

• 국내 보안체계는 문서와 체크리스트 중심으로, 공격 대응보다 규정 준수 점검에 머물러 있음.
• AI 시대에는 사후 대응 중심이 아닌, 선제적·예방적 보안 정책과 복원력 중심 운영 체계가 필요.

2. 최근 AI 보안 위험 사례

• 국내 해킹과 개인정보 유출 사고를 통해 단순 공격 기술의 고도화뿐 아니라, 인증 장치와 통제 체계 미비가 문제로 지적됨.
• 생성형 AI, 자동화 콘텐츠 생성, 로봇/드론/자율주행차 등과 같은 AI 에이전트의 확산으로 기존 보안 경계만으로는 대응 불가.

3. 국제 보안 흐름과 규제

• 미국: AI 기반 위험 대응·국가 전략 자산 관리 중심, 산업과 국가 전략 결합 강조.
• 유럽: AI 모델 투명성, 학습 데이터 관리 강화, 인권·사회적 책임 고려.
• 국제적으로 AI 거버넌스와 통합 관리 필요성이 부각됨.

4. 한국형 AI 보안 전략

• 기존 해외 모델을 단순 적용하는 방식은 한계. 국내 환경과 산업 구조에 맞는 특화 모델과 체계 필요.
• AI 기반 위험 인텔리전스 체계 구축, 민간과 공공의 대응 협력 필요.
• AI 경쟁력 강화를 위해 보안 R&D, 상시 검증, 공급망 보안, 데이터 센터 및 전력망 보호가 병행되어야 함.

5. 정책 과제 및 실행

• 문서·점검 중심에서 벗어나, 실제 침해 상황을 고려한 정책 설계 필요.
• 공격 표면 관리, 취약점 관리, VDP(Vulnerability Disclosure Program) 등 제도화 필요.

🔑 주요 키워드 정리

1️⃣ AI 3강 'AI 3강'은 대한민국 정부가 인공지능(AI) 분야에서 미국, 중국과 함께 세계 3대 강국(G3)으로 도약하겠다는 목표

2️⃣ CISO 정보보호 최고책임자

3️⃣ AI 액션 플랜 조직이 AI를 효과적으로 도입·운영하기 위해 세워놓은 구체적인 실행 전략과 단계별 계획

4️⃣ 거버넌스 어떻게 의사결정하고, 누가 책임지고, 어떤 기준으로 운영할지 정해놓은 체계

5️⃣ 공격표면관리 공격표면관리(ASM, Attack Surface Management)는 기업의 IT 환경에서 해커가 악용할 수 있는 모든 디지털 자산과 취약점(공격 표면)을 외부 공격자 관점에서 지속적으로 발견, 분석, 모니터링하여 보안 위협을 선제적으로 줄이는 프로세스 및 기술

6️⃣ VDP 보안 분야(Vulnerability Disclosure Program)에서는 외부 보안 연구원들이 시스템의 취약점을 안전하게 제보할 수 있도록 유도하는 프로그램

💡 나의 생각

최근 기사와 자료를 보면서, 공격자와 방어자 모두 AI를 활용하는 시대가 이미 현실이라는 점을 다시 실감했다. 특히, 국내에서 발생한 대형 해킹 사건을 보면, 규모가 큰 기업조차도 AI 기반 공격을 완벽히 막기 어렵다는 사실이 보안 취약성에 대해 다시 생각하게 만들었다. 기사에서는 인증·인가 통제와 같은 기본적인 보안 체계가 제대로 작동하지 않았고, 사고 발생 후에도 신속한 대응이 이뤄지지 않은 점이 근본적인 문제로 지적되었다.

앞으로는 에이전트형 AI가 확산되고, 드론이나 자율주행과 같은 피지컬 AI까지 서비스 영역을 넓혀가는 상황에서, “권한을 가진 비인간 주체”를 어떻게 통제할 것인가가 새로운 고민거리가 되었다. 글을 읽으면서 “아… 물리적으로 영향을 줄 수 있는 시대가 왔구나”라는 점이 가장 인상 깊었다.

또한, 최근 클로드 코드 악용 공격이나 오픈클로 사태처럼, 통제되지 않은 상태로 AI가 확산될 경우 새로운 유형의 공급망 위협이 발생할 수 있다는 점도 주목할 필요가 있다. 이러한 사례들은 다음 리뷰에서 자세히 다루고 싶다.

기사에서 강조한 것처럼, 정책도 이제 AI 세이프티 중심에서 AI 보안 중심으로 이동하고 있다. 전 세계적으로 AI 보안이 국가 안보와 직결되면서, AI 보안이 곧 국가 전략의 핵심 요소가 될 수 있다는 점을 깨닫게 되었다.

공격표면 관리, 즉 공격자의 시각에서 취약 정보를 지속적으로 모니터링하고 대응하는 접근법이 더 강하게 반영되어야 한다는 점도 중요하다. 이러한 기본기 강화와 제도적 보완을 통해, 한국의 보안 산업과 정책 체계를 보다 촘촘하게 만들 수 있을 것으로 보인다.

마지막으로, 보안은 개인정보 보호와도 긴밀하게 연결되어 있어 법적·제도적 과제도 함께 고려해야 한다. 앞으로 AI 시대의 보안 정책이 안정적으로 설계되고, 현실과 문제의식을 반영한 법 체계가 마련되길 기대한다.