diff --git a/docs/README.md b/docs/README.md
index e69de29bb2d..60915dd25bf 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -0,0 +1,166 @@
+# 💻 프로그램 동작 방식
+
+---
+
+#### 1. 사용자로부터 `InputView`에서 값을 입력 받고 초기화 후, 게임을 실행한다.
+#### 2. `InputView`에서 값을 입력 받는다.
+#### 3. `Validator`를 통해 입력값을 검증한다.
+#### 4. 예외 발생시 재입력받는다.
+#### 5. 예외가 발생하지 않을 경우, `Application`에 값을 반환한다.
+#### 6. `BridgeGame`에 해당 값을 넘겨주어 update한다.
+#### 7. update된 `BridgeGame`을 `Application`에서 `OutputView`로 넘겨준다.
+#### 8. 해당 값을 활용해 출력한다.
+#### 9. 게임이 종료될 때 까지 2~8를 반복한다.
+
+
+# 🧰 기능 목록
+
+---
+
+### 1. 게임 시작 문구를 출력한다. - `View`/`InputView`
+
+### 2. 다리의 길이를 숫자를 입력받고 생성한다.
+   - [x] 입력받은 숫자(문자열)을 정수로 변환한다. - `Domain`/`InputConverter`
+      - [x] 숫자가 아닌 입력일 경우(문자, 빈 문자열) 예외를 던진다. - `Domain`/`InputValidator`
+      - [x] 잘못된 입력일 경우, 올바른 입력이 될 때 까지 입력받는다. - from `Application` call `View`/`InputView`
+   - [x] 입력받은 숫자가 3 이상 20 이하인지 확인하고 아니면 예외를 던진다. - `Domain`/`InputValidator`
+   - [x] 0과 1을 다리 길이만큼 무작위로 생성한다. - `BridgeMaker` from `BridgeRandomNumberGenerator`
+   - [x] 0인 경우 아랫 칸인 `D`, 1인 경우 윗 칸인 `U`인 다리 리스트를 만든다. - from `Domain`/`Bridge` call `BridgeMaker`
+### 3.`U` 또는 `D`를 입력받아 이동할 칸을 선택한다. `View`/`InputView`
+   - [x] 정해진 문자가 아니거나 입력이 없으면 예외를 던진다. - `Domain`/`InputValidator`
+   - [x] 예외가 발생할 경우, 다시 입력받도록 한다. - from `Application` call `View`/`InputView`
+   - [x] 이동 후 생사여부를 update한다 - in `Domain`/`BridgeGame` update `Domain`/`Player` 
+
+### 4. 입력 결과를 출력한다.
+  - [X] 건너온 칸들은 전부 O로 출력하고 칸 일치여부와 생사여부에 따라 O, X를 출력을 결정한다. - from `Application` call `View`/`OutputView`
+
+### 5. 생사여부를 판별 후, 다음 행동을 결정한다.
+  #### 5-1. 죽었을 때
+   - [x] 건너다 실패하면 재시작 `R`, 종료 `Q` 할 수 있다. `View`/`InputView`
+   - [x] 정해진 문자가 아니거나 입력이 없으면 예외를 던진다 `Domain`/`InputValidator`
+   - [x] 예외가 발생할 경우, 다시 입력받도록 한다. from `Application` call `View`/`InputView`
+   - [x] 재시작시 처음부터 다시 진행한다. - `Application`
+
+  #### 5-2. 살았을 때
+- [x] 끝에 도달할 때 까지 계속 진행한다. - `Application`
+
+
+### 6. 게임 종료시 결과를 출력한다. `OutputView`/`printResult`
+  - [x] 최고 기록을 출력한다. 
+  - [x] 게임 성공 여부를 출력한다.
+  - [x] 총 시도 횟수를 출력한다.
+
+   
+
+
+
+# 🛠️ 클래스 설계
+
+---
+
+## BridgeMaker
+```
+    - Bridge를 랜덤한 길이로 생성
+```
+
+## Constant
+
+---
+
+- ### InputValue
+```
+  - 사용자 입력값으로 이루어진 상수 클래스
+```
+
+- ### OutputValue
+```
+  - 출력값으로 이루어진 상수 클래스
+```
+
+
+## Util
+
+---
+
+- ### InputConverter
+```
+  - 사용자가 입력한 값(문자열)을 정수로 변환해 return
+  - 변환 불가시 예외를 던짐
+```
+
+- ### InputValidator
+```
+    - 입력값에 대한 검증
+    - 올바르지 않은 입력일 시 예외를 던짐
+```
+
+
+## Model
+
+---
+
+- ### Bridge
+```
+    - 게임에 사용되는 다리 정보
+```
+
+- ### BridgeBlock
+```
+    - 사용자 선택 정보를 열거형 상수로 지정한 enum 클래스
+```
+
+- ### Player
+```
+    - 현재 위치
+    - 생사 여부
+```
+
+- ### BridgeGame
+```
+    - 게임 상태 및 제어에 관련된 클래스
+    - 주어진 값에 대한 검증
+    - 개수를 입력받고 Bridge 모델 초기화
+    - 입력값에 따라 유저의 생사 여부 및 위치 결정
+    - 최고 기록을 저장
+```
+
+
+## View
+
+---
+
+- ### InputView
+```
+    - 게임 시작 문구 출력
+    - 입력 문구 출력
+    - 입력받은 값을 검증 후 반환
+```
+### OutputView
+```
+    - 결과 문구 출력
+    - update된 정보를 가공하여 출력
+```
+
+
+
+# ❗ 주의사항 체크 리스트
+
+---
+
+- [x] `Exception`이 아닌 `IllegalArgumentException`과 같이 명확하게 유형을 처리하였는가?
+- [x] 입출력 요구 사항을 모두 지켰는가?
+  - [x] 게임 시작 문구
+  - [x] 길이 입력 문구
+  - [x] 칸 입력 문구
+  - [x] 칸 입력 후 다리 상태
+  - [x] 실패했을 시 재시도, 종료 여부
+  - [x] 게임 성공 여부 및 시도 횟수
+- [x] 함수(또는 메소드)의 길이가 10라인 이내인가? (빈줄 포함)
+- [x] 함수(또는 메소드)의 파라미터가 3개 이하인가?
+- [x] 클래스 제약 사항들을 모두 지켰는가?
+  - [x] `OutuptView`의 메소드 이름을 변경하면 안된다. (printMap, printResult)
+  - [x] `BridgeMaker`의 메소드의 시그니처(인자, 이름)와 반환 타입을 변경하면 안된다.
+  - [x] `BridgeGame`의 메소드 이름을 변경하면 안된다. (move, retry)
+  - [x] `InputView` 클래스에서만 `readLine()`을 사용한다. 
+  - [x] `BridgeRandomNumberGenerator`, `BridgeNumberGenerator`의 를 수정하면 안된다.
+  - [x] `BridgeRandomNumberGenerator`, `BridgeNumberGenerator`의 패키지를 수정하면 안된다.
diff --git a/src/main/java/bridge/Application.java b/src/main/java/bridge/Application.java
index 5cb72dfd3de..7efd6acfb2d 100644
--- a/src/main/java/bridge/Application.java
+++ b/src/main/java/bridge/Application.java
@@ -1,8 +1,73 @@
 package bridge;
 
+import bridge.Model.BridgeGame;
+import bridge.View.InputView;
+import bridge.View.OutputView;
+
+
+
 public class Application {
+    private static InputView inputView = new InputView();
+    private static OutputView outputView = new OutputView();
+
+
+    public static BridgeGame initiateBridgeGame() {
+        while (true) {
+            try {
+                int size = inputView.readBridgeSize();
+
+                return new BridgeGame(size);
+            } catch (IllegalArgumentException illegalArgumentException) {
+                System.out.println(illegalArgumentException.getMessage());
+            }
+        }
+    }
+
+    public static void inputMoving(BridgeGame bridgeGame) {
+        while (true) {
+            try {
+                String selection = inputView.readMoving();
+                bridgeGame.move(selection);
+
+                return;
+            } catch (IllegalArgumentException illegalArgumentException) {
+                System.out.println(illegalArgumentException.getMessage());
+            }
+        }
+    }
+
+    public static void inputCommand(BridgeGame bridgeGame) {
+        while (true) {
+            try {
+                String command = inputView.readGameCommand();
+                bridgeGame.retry(command);
+
+                return;
+            } catch (IllegalArgumentException illegalArgumentException) {
+                System.out.println(illegalArgumentException.getMessage());
+            }
+        }
+    }
+
+    public static void run(BridgeGame bridgeGame) {
+        while (!bridgeGame.isGameOver()) {
+            inputMoving(bridgeGame);
+            outputView.printMap(bridgeGame, bridgeGame.getPassedCount());
+            bridgeGame.updatePlayer();
+
+            if (bridgeGame.isPlayerDead()) {
+                inputCommand(bridgeGame);
+            }
+        }
+    }
 
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        inputView.printStartMessage();
+
+        BridgeGame bridgeGame = initiateBridgeGame();
+
+        run(bridgeGame);
+
+        outputView.printResult(bridgeGame);
     }
 }
diff --git a/src/main/java/bridge/BridgeGame.java b/src/main/java/bridge/BridgeGame.java
deleted file mode 100644
index 834c1c8362b..00000000000
--- a/src/main/java/bridge/BridgeGame.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package bridge;
-
-/**
- * 다리 건너기 게임을 관리하는 클래스
- */
-public class BridgeGame {
-
-    /**
-     * 사용자가 칸을 이동할 때 사용하는 메서드
-     * <p>
-     * 이동을 위해 필요한 메서드의 반환 타입(return type), 인자(parameter)는 자유롭게 추가하거나 변경할 수 있다.
-     */
-    public void move() {
-    }
-
-    /**
-     * 사용자가 게임을 다시 시도할 때 사용하는 메서드
-     * <p>
-     * 재시작을 위해 필요한 메서드의 반환 타입(return type), 인자(parameter)는 자유롭게 추가하거나 변경할 수 있다.
-     */
-    public void retry() {
-    }
-}
diff --git a/src/main/java/bridge/BridgeMaker.java b/src/main/java/bridge/BridgeMaker.java
index 27e9f2cfa7f..07341e08dce 100644
--- a/src/main/java/bridge/BridgeMaker.java
+++ b/src/main/java/bridge/BridgeMaker.java
@@ -1,10 +1,14 @@
 package bridge;
 
+import bridge.Model.BridgeBlock;
+
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
+
+
 
-/**
- * 다리의 길이를 입력 받아서 다리를 생성해주는 역할을 한다.
- */
 public class BridgeMaker {
 
     private final BridgeNumberGenerator bridgeNumberGenerator;
@@ -13,11 +17,24 @@ public BridgeMaker(BridgeNumberGenerator bridgeNumberGenerator) {
         this.bridgeNumberGenerator = bridgeNumberGenerator;
     }
 
-    /**
-     * @param size 다리의 길이
-     * @return 입력받은 길이에 해당하는 다리 모양. 위 칸이면 "U", 아래 칸이면 "D"로 표현해야 한다.
-     */
+
     public List<String> makeBridge(int size) {
-        return null;
+        List<Integer> bridgeNumbers = generateBridgeNumbers(size);
+        List<String> bridge = bridgeNumbers.stream()
+                .map(bridgeNumber -> BridgeBlock.getBlockIdentifier((bridgeNumber)))
+                .collect(Collectors.toList());
+
+        return Collections.unmodifiableList(bridge);
+    }
+
+    private List<Integer> generateBridgeNumbers(int size) {
+        List<Integer> bridgeNumbers = new ArrayList<>(size);
+
+        for (int i = 0; i < size; i++) {
+            int blockNumber = bridgeNumberGenerator.generate();
+            bridgeNumbers.add(blockNumber);
+        }
+
+        return bridgeNumbers;
     }
 }
diff --git a/src/main/java/bridge/BridgeNumberGenerator.java b/src/main/java/bridge/BridgeNumberGenerator.java
index 56187b71d2d..f201d1b1438 100644
--- a/src/main/java/bridge/BridgeNumberGenerator.java
+++ b/src/main/java/bridge/BridgeNumberGenerator.java
@@ -1,7 +1,8 @@
 package bridge;
 
+
+
 @FunctionalInterface
 public interface BridgeNumberGenerator {
-
     int generate();
 }
diff --git a/src/main/java/bridge/BridgeRandomNumberGenerator.java b/src/main/java/bridge/BridgeRandomNumberGenerator.java
index 4c9cb53e03a..35915c4d98a 100644
--- a/src/main/java/bridge/BridgeRandomNumberGenerator.java
+++ b/src/main/java/bridge/BridgeRandomNumberGenerator.java
@@ -2,6 +2,8 @@
 
 import camp.nextstep.edu.missionutils.Randoms;
 
+
+
 public class BridgeRandomNumberGenerator implements BridgeNumberGenerator {
 
     private static final int RANDOM_LOWER_INCLUSIVE = 0;
diff --git a/src/main/java/bridge/Constant/InputValue.java b/src/main/java/bridge/Constant/InputValue.java
new file mode 100644
index 00000000000..cc21fe617f7
--- /dev/null
+++ b/src/main/java/bridge/Constant/InputValue.java
@@ -0,0 +1,10 @@
+package bridge.Constant;
+
+
+
+public class InputValue {
+    public static final String SELECTION_UP = "U";
+    public static final String SELECTION_DOWN = "D";
+    public static final String COMMAND_RETRY = "R";
+    public static final String COMMAND_QUIT =  "Q";
+}
diff --git a/src/main/java/bridge/Constant/OutputValue.java b/src/main/java/bridge/Constant/OutputValue.java
new file mode 100644
index 00000000000..cba86ea61d7
--- /dev/null
+++ b/src/main/java/bridge/Constant/OutputValue.java
@@ -0,0 +1,12 @@
+package bridge.Constant;
+
+
+
+public class OutputValue {
+    public static final String SEPARATOR = "|";
+    public static final String NOT_SELECTION = "   ";
+    public static final String WRONG_SELECTION = " X ";
+    public static final String RIGHT_SELECTION = " O ";
+    public static final String SUCCESS = "성공";
+    public static final String FAIL = "실패";
+}
diff --git a/src/main/java/bridge/InputView.java b/src/main/java/bridge/InputView.java
deleted file mode 100644
index c3911c8a8e7..00000000000
--- a/src/main/java/bridge/InputView.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package bridge;
-
-/**
- * 사용자로부터 입력을 받는 역할을 한다.
- */
-public class InputView {
-
-    /**
-     * 다리의 길이를 입력받는다.
-     */
-    public int readBridgeSize() {
-        return 0;
-    }
-
-    /**
-     * 사용자가 이동할 칸을 입력받는다.
-     */
-    public String readMoving() {
-        return null;
-    }
-
-    /**
-     * 사용자가 게임을 다시 시도할지 종료할지 여부를 입력받는다.
-     */
-    public String readGameCommand() {
-        return null;
-    }
-}
diff --git a/src/main/java/bridge/Model/Bridge.java b/src/main/java/bridge/Model/Bridge.java
new file mode 100644
index 00000000000..31a0b608980
--- /dev/null
+++ b/src/main/java/bridge/Model/Bridge.java
@@ -0,0 +1,49 @@
+package bridge.Model;
+
+import bridge.BridgeMaker;
+import bridge.BridgeNumberGenerator;
+import bridge.BridgeRandomNumberGenerator;
+
+import java.util.List;
+
+
+
+public class Bridge {
+    private final static int MIN_BRIDGE_SIZE = 3;
+    private final static int MAX_BRIDGE_SIZE = 20;
+    private final static String WRONG_RANGE_INPUT = "[ERROR] 다리 길이는 %d부터 %d 사이의 숫자여야 합니다." + System.lineSeparator();
+
+
+    private final List<String> bridgeStates;
+
+
+    public Bridge(int bridgeSize) throws IllegalArgumentException {
+        try {
+            validate(bridgeSize);
+        } catch (IllegalArgumentException illegalArgumentException) {
+            throw illegalArgumentException;
+        }
+
+        BridgeNumberGenerator bridgeRandomNumberGenerator = new BridgeRandomNumberGenerator();
+        BridgeMaker bridgeMaker = new BridgeMaker(bridgeRandomNumberGenerator);
+
+        bridgeStates = bridgeMaker.makeBridge(bridgeSize);
+    }
+
+
+    public void validate(int bridgeSize) throws IllegalArgumentException {
+        if (bridgeSize < MIN_BRIDGE_SIZE || MAX_BRIDGE_SIZE < bridgeSize) {
+            String rangeError = String.format(WRONG_RANGE_INPUT, MIN_BRIDGE_SIZE, MAX_BRIDGE_SIZE);
+
+            throw new IllegalArgumentException(rangeError);
+        }
+    }
+
+    public List<String> getBridgeStates() {
+        return bridgeStates;
+    }
+
+    public String getBridgeState(int bridgeLocation) {
+        return bridgeStates.get(bridgeLocation);
+    }
+}
diff --git a/src/main/java/bridge/Model/BridgeBlock.java b/src/main/java/bridge/Model/BridgeBlock.java
new file mode 100644
index 00000000000..a033bfc79c6
--- /dev/null
+++ b/src/main/java/bridge/Model/BridgeBlock.java
@@ -0,0 +1,29 @@
+package bridge.Model;
+
+import java.util.Arrays;
+
+
+
+public enum BridgeBlock {
+    UP("U", 1),
+    DOWN("D", 0);
+
+
+    private final String blockIdentifier;
+    private final int blockNumber;
+
+
+    BridgeBlock(String blockIdentifier, int blockNumber) {
+        this.blockIdentifier = blockIdentifier;
+        this.blockNumber = blockNumber;
+    }
+
+
+    public static String getBlockIdentifier(int blockNumber) {
+        return Arrays.stream(BridgeBlock.values())
+                .filter(block -> block.blockNumber == blockNumber)
+                .findAny()
+                .get()
+                .blockIdentifier;
+    }
+}
diff --git a/src/main/java/bridge/Model/BridgeGame.java b/src/main/java/bridge/Model/BridgeGame.java
new file mode 100644
index 00000000000..285246b5e59
--- /dev/null
+++ b/src/main/java/bridge/Model/BridgeGame.java
@@ -0,0 +1,105 @@
+package bridge.Model;
+
+import static bridge.Constant.InputValue.COMMAND_RETRY;
+
+import java.util.List;
+
+
+
+public class BridgeGame {
+    private final Bridge bridge;
+    private final Player player;
+    private int retryCount;
+    private int maxPassedCount;
+
+
+    public BridgeGame(int size) throws IllegalArgumentException {
+        try {
+            this.bridge = new Bridge(size);
+            this.player = new Player();
+            this.retryCount = 1;
+            this.maxPassedCount = 0;
+        } catch (IllegalArgumentException illegalArgumentException) {
+            throw illegalArgumentException;
+        }
+    }
+
+
+    public void move(String playerSelection) {
+        int nextPlayerLocation = player.getPassedCount();
+        String nextBridgeState = bridge.getBridgeState(nextPlayerLocation);
+
+        if (!playerSelection.equals(nextBridgeState)) {
+            player.die();
+        }
+    }
+
+    public void retry(String command) {
+        updateMaxPassedCount();
+
+        if (command.equals(COMMAND_RETRY)) {
+            player.revive();
+            retryCount++;
+        }
+    }
+
+    public void updateMaxPassedCount() {
+        int passedCount = player.getPassedCount();
+
+        if (maxPassedCount < passedCount) {
+            maxPassedCount = passedCount;
+        }
+    }
+
+    public boolean winGame() {
+        int playerNextLocation = player.getPassedCount();
+        List<String> bridgeStates = bridge.getBridgeStates();
+
+        if (bridgeStates.size() <= playerNextLocation) {    // 다음에 이동할 곳이 인덱스를 벗어날 경우 끝에 도달한 것
+            maxPassedCount = playerNextLocation - 1;
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public boolean isGameOver() {
+        if (isPlayerDead() || winGame()) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public boolean isPlayerDead() {
+        if (player.isAlive()) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public void updatePlayer() {
+        if (player.isAlive()) {
+            player.success();
+        }
+    }
+
+    //getter
+    public List<String> getBridgeStates() {
+        return bridge.getBridgeStates();
+    }
+
+    public int getRetryCount() {
+        return retryCount;
+    }
+
+    public int getMaxPassedCount() {
+        return maxPassedCount;
+    }
+
+    public int getPassedCount() {
+        return player.getPassedCount();
+    }
+}
diff --git a/src/main/java/bridge/Model/Player.java b/src/main/java/bridge/Model/Player.java
new file mode 100644
index 00000000000..c062b4753f7
--- /dev/null
+++ b/src/main/java/bridge/Model/Player.java
@@ -0,0 +1,37 @@
+package bridge.Model;
+
+
+
+public class Player {
+    private int passedCount;
+    private boolean alive;
+
+
+    public Player() {
+        this.passedCount = 0;
+        this.alive = true;
+    }
+
+
+    public void die() {
+        alive = false;
+    }
+
+    public void success() {
+        passedCount++;
+    }
+
+    public void revive() {
+        alive = true;
+        passedCount = 0;
+    }
+
+    // getter
+    public boolean isAlive() {
+        return alive;
+    }
+
+    public int getPassedCount() {
+        return passedCount;
+    }
+}
diff --git a/src/main/java/bridge/OutputView.java b/src/main/java/bridge/OutputView.java
deleted file mode 100644
index 69a433a6285..00000000000
--- a/src/main/java/bridge/OutputView.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package bridge;
-
-/**
- * 사용자에게 게임 진행 상황과 결과를 출력하는 역할을 한다.
- */
-public class OutputView {
-
-    /**
-     * 현재까지 이동한 다리의 상태를 정해진 형식에 맞춰 출력한다.
-     * <p>
-     * 출력을 위해 필요한 메서드의 인자(parameter)는 자유롭게 추가하거나 변경할 수 있다.
-     */
-    public void printMap() {
-    }
-
-    /**
-     * 게임의 최종 결과를 정해진 형식에 맞춰 출력한다.
-     * <p>
-     * 출력을 위해 필요한 메서드의 인자(parameter)는 자유롭게 추가하거나 변경할 수 있다.
-     */
-    public void printResult() {
-    }
-}
diff --git a/src/main/java/bridge/Util/InputConverter.java b/src/main/java/bridge/Util/InputConverter.java
new file mode 100644
index 00000000000..1fe2b7de4c9
--- /dev/null
+++ b/src/main/java/bridge/Util/InputConverter.java
@@ -0,0 +1,15 @@
+package bridge.Util;
+
+
+
+public class InputConverter {
+    public static int convertToInt(String input) throws IllegalArgumentException {
+        try {
+            InputValidator.validateNumberInput(input);
+        } catch (IllegalArgumentException illegalArgumentException) {
+            throw illegalArgumentException;
+        }
+
+        return Integer.parseInt(input);
+    }
+}
diff --git a/src/main/java/bridge/Util/InputValidator.java b/src/main/java/bridge/Util/InputValidator.java
new file mode 100644
index 00000000000..0f04945f114
--- /dev/null
+++ b/src/main/java/bridge/Util/InputValidator.java
@@ -0,0 +1,50 @@
+package bridge.Util;
+
+import static bridge.Constant.InputValue.COMMAND_QUIT;
+import static bridge.Constant.InputValue.COMMAND_RETRY;
+import static bridge.Constant.InputValue.SELECTION_DOWN;
+import static bridge.Constant.InputValue.SELECTION_UP;
+
+
+
+public class InputValidator {
+    private static final String ERROR_PREFIX = "[ERROR]";
+    private static final String EMPTY_INPUT = ERROR_PREFIX + "빈 문자입니다.";
+    private static final String WRONG_SIZE_INPUT = ERROR_PREFIX + "숫자만 입력 가능합니다.";
+    private static final String WRONG_SELECTION_INPUT = ERROR_PREFIX + "'U' 또는 'D'만 입력 가능합니다.";
+    private static final String WRONG_COMMAND_INPUT = ERROR_PREFIX + "종료를 위해서는 'Q', 재시작을 위해서는 'R을 입력해주세요.";
+
+
+    public static void validateNumberInput(String input) throws IllegalArgumentException {
+        final String NUMBER_REGEX = "[0-9]+";
+
+        if (input.isBlank()) {
+            throw new IllegalArgumentException(EMPTY_INPUT);
+        }
+
+        if (!input.matches(NUMBER_REGEX)) {
+            throw new IllegalArgumentException(WRONG_SIZE_INPUT);
+        }
+    }
+
+    public static void validateSelectionInput(String input) throws IllegalArgumentException {
+        if (input.isBlank()) {
+            throw new IllegalArgumentException(EMPTY_INPUT);
+        }
+
+        if (!input.equals(SELECTION_UP) && !input.equals(SELECTION_DOWN)) {
+            throw new IllegalArgumentException(WRONG_SELECTION_INPUT);
+        }
+    }
+
+    public static void validateCommandInput(String input) throws IllegalArgumentException {
+        if (input.isBlank()) {
+            throw new IllegalArgumentException(EMPTY_INPUT);
+        }
+
+        if (!input.equals(COMMAND_RETRY) && !input.equals(COMMAND_QUIT)) {
+            throw new IllegalArgumentException(WRONG_COMMAND_INPUT);
+        }
+    }
+
+}
diff --git a/src/main/java/bridge/View/InputView.java b/src/main/java/bridge/View/InputView.java
new file mode 100644
index 00000000000..c53c894a0aa
--- /dev/null
+++ b/src/main/java/bridge/View/InputView.java
@@ -0,0 +1,60 @@
+package bridge.View;
+
+import static camp.nextstep.edu.missionutils.Console.readLine;
+
+import bridge.Util.InputConverter;
+import bridge.Util.InputValidator;
+
+
+
+public class InputView {
+    private static final String START_GAME = "다리 건너기 게임을 시작합니다.";
+    private static final String INPUT_BRIDGE_SIZE = "다리의 길이를 입력해주세요.";
+    private static final String INPUT_SELECTION = "이동할 칸을 선택해주세요. (위: U, 아래: D)";
+    private static final String INPUT_COMMAND = "게임을 다시 시도할지 여부를 입력해주세요. (재시도: R, 종료: Q)";
+
+
+    public void printStartMessage() {
+        System.out.println(START_GAME);
+        System.out.println();
+    }
+
+    public int readBridgeSize() throws IllegalArgumentException {
+        System.out.println(INPUT_BRIDGE_SIZE);
+        String input = readLine();
+
+        try {
+            int bridgeSize = InputConverter.convertToInt(input);
+
+            return bridgeSize;
+        } catch (IllegalArgumentException illegalArgumentException) {
+            throw illegalArgumentException;
+        }
+    }
+
+    public String readMoving() throws IllegalArgumentException {
+        System.out.println(INPUT_SELECTION);
+        String input = readLine();
+
+        try {
+            InputValidator.validateSelectionInput(input);
+
+            return input;
+        } catch (IllegalArgumentException illegalArgumentException) {
+            throw illegalArgumentException;
+        }
+    }
+
+    public String readGameCommand() throws IllegalArgumentException {
+        System.out.println(INPUT_COMMAND);
+        String input = readLine();
+
+        try {
+            InputValidator.validateCommandInput(input);
+
+            return input;
+        } catch (IllegalArgumentException illegalArgumentException) {
+            throw illegalArgumentException;
+        }
+    }
+}
diff --git a/src/main/java/bridge/View/OutputView.java b/src/main/java/bridge/View/OutputView.java
new file mode 100644
index 00000000000..5818db745c0
--- /dev/null
+++ b/src/main/java/bridge/View/OutputView.java
@@ -0,0 +1,89 @@
+package bridge.View;
+
+import static bridge.Constant.InputValue.SELECTION_DOWN;
+import static bridge.Constant.InputValue.SELECTION_UP;
+
+import static bridge.Constant.OutputValue.*;
+
+import bridge.Model.BridgeGame;
+
+import java.util.List;
+
+
+
+public class OutputView {
+    private static final String RESULT_MESSAGE = "최종 게임 결과";
+    private static final String BRIDGE_MAP = "[%s]" + System.lineSeparator();
+    private static final String IS_SUCCESS = "게임 성공 여부: %s" + System.lineSeparator();
+    private static final String RETRY_COUNT = "총 시도한 횟수: %d" + System.lineSeparator();
+
+
+    private String getIsPassedStair(String bridgeState, String stair) {
+        if (bridgeState.equals(stair)) {
+            return RIGHT_SELECTION;
+        }
+
+        return NOT_SELECTION;
+    }
+
+    private String getPassedStair(List<String> bridgeStates, int passedCount, String stair) {
+        String result = "";
+
+        for (int bridgeLocation = 0; bridgeLocation < passedCount; bridgeLocation++) {
+            String bridgeState = bridgeStates.get(bridgeLocation);
+
+            result += getIsPassedStair(bridgeState, stair);
+            result += SEPARATOR;
+        }
+
+        return result;
+    }
+
+    private void printStair(BridgeGame bridgeGame, int passedCount, String stair) {
+        List<String> bridgeStates = bridgeGame.getBridgeStates();
+        String selectedBridgeState = bridgeStates.get(passedCount);
+        boolean playerDead = bridgeGame.isPlayerDead();
+
+        String result = getPassedStair(bridgeStates, passedCount, stair)
+                + getSelectResult(playerDead, selectedBridgeState, stair);
+
+        System.out.printf(BRIDGE_MAP, result);
+    }
+
+    private String getIsSuccess(boolean playerDead) {
+        if (playerDead) {
+            return FAIL;
+        }
+
+        return SUCCESS;
+    }
+
+    private String getSelectResult(boolean playerDead, String bridgeState, String stair) {
+        if (!playerDead && bridgeState.equals(stair)) {
+            return RIGHT_SELECTION;
+        }
+
+        if (playerDead && !bridgeState.equals(stair)) {
+            return WRONG_SELECTION;
+        }
+
+        return NOT_SELECTION;
+    }
+
+    public void printMap(BridgeGame bridgeGame, int passedCount) {
+        printStair(bridgeGame, passedCount, SELECTION_UP);
+        printStair(bridgeGame, passedCount, SELECTION_DOWN);
+        System.out.println();
+    }
+
+    public void printResult(BridgeGame bridgeGame) {
+        int maxPassedCount = bridgeGame.getMaxPassedCount();
+
+        System.out.println(RESULT_MESSAGE);
+
+        printMap(bridgeGame, maxPassedCount);
+
+        System.out.printf(IS_SUCCESS, getIsSuccess(bridgeGame.isPlayerDead()));
+        System.out.printf(RETRY_COUNT, bridgeGame.getRetryCount());
+    }
+}
diff --git a/src/test/java/bridge/ApplicationTest.java b/src/test/java/bridge/ApplicationTest.java
index 1a163ec0a2a..13ba1d376b3 100644
--- a/src/test/java/bridge/ApplicationTest.java
+++ b/src/test/java/bridge/ApplicationTest.java
@@ -7,6 +7,7 @@
 
 import camp.nextstep.edu.missionutils.test.NsTest;
 import java.util.List;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 class ApplicationTest extends NsTest {
@@ -39,6 +40,62 @@ class ApplicationTest extends NsTest {
         }, 1, 0, 1);
     }
 
+ 
+    @Test
+    void 기능_테스트_실패_후_성공() {
+        assertRandomNumberInRangeTest(() -> {
+            run("3", "U", "U", "R", "D", "R", "U", "D", "U");
+            assertThat(output()).contains(
+                    "[ O | X ]",
+                    "[   |   ]",
+                    "[   ]",
+                    "[ X ]",
+                    "최종 게임 결과",
+                    "[ O |   | O ]",
+                    "[   | O |   ]",
+                    "게임 성공 여부: 성공",
+                    "총 시도한 횟수: 3"
+            );
+        }, 1, 0, 1);
+    }
+    @DisplayName("재시작 전후로 서로 다른 값일 경우")
+    @Test
+    void 기능_테스트_실패_후_종료_다른값() {
+        assertRandomNumberInRangeTest(() -> {
+            run("3", "U", "U", "R", "D", "Q");
+            assertThat(output()).containsSubsequence(
+                    "[ O | X ]",
+                    "[   |   ]",
+                    "[   ]",
+                    "[ X ]",
+                    "최종 게임 결과",
+                    "[ O | X ]",
+                    "[   |   ]",
+                    "게임 성공 여부: 실패",
+                    "총 시도한 횟수: 2"
+            );
+        }, 1, 0, 1);
+    }
+
+    @DisplayName("재시작 전후로 서로 같은 값일 경우")
+    @Test
+    void 기능_테스트_실패_후_종료_같은값() {
+        assertRandomNumberInRangeTest(() -> {
+            run("3", "U", "D", "R", "D", "Q");
+            assertThat(output()).containsSubsequence(
+                    "[ O |   ]",
+                    "[   | X ]",
+                    "[   ]",
+                    "[ X ]",
+                    "최종 게임 결과",
+                    "[ O |   ]",
+                    "[   | X ]",
+                    "게임 성공 여부: 실패",
+                    "총 시도한 횟수: 2"
+            );
+        }, 1, 1, 1);
+    }
+
     @Test
     void 예외_테스트() {
         assertSimpleTest(() -> {
diff --git a/src/test/java/bridge/Model/BridgeBlockTest.java b/src/test/java/bridge/Model/BridgeBlockTest.java
new file mode 100644
index 00000000000..e24340a0291
--- /dev/null
+++ b/src/test/java/bridge/Model/BridgeBlockTest.java
@@ -0,0 +1,30 @@
+package bridge.Model;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static bridge.Constant.InputValue.SELECTION_DOWN;
+import static bridge.Constant.InputValue.SELECTION_UP;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+
+class BridgeBlockTest {
+    private static final int SELECTION_UP_NUMBER = 1;
+    private static final int SELECTION_DOWN_NUMBER = 0;
+
+    @DisplayName("생성 번호에 따른 올바른 문자 반환하는지 테스트")
+    @Nested
+    class StringReturnTest {
+        @Test
+        void 반환_올바른_문자_UP() {
+            assertThat(BridgeBlock.getBlockIdentifier(SELECTION_UP_NUMBER)).isEqualTo(SELECTION_UP);
+        }
+        @Test
+        void 반환_올바른_문자_DOWN() {
+            assertThat(BridgeBlock.getBlockIdentifier(SELECTION_DOWN_NUMBER)).isEqualTo(SELECTION_DOWN);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/bridge/Model/BridgeGameTest.java b/src/test/java/bridge/Model/BridgeGameTest.java
new file mode 100644
index 00000000000..1571dc6db61
--- /dev/null
+++ b/src/test/java/bridge/Model/BridgeGameTest.java
@@ -0,0 +1,28 @@
+package bridge.Model;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static camp.nextstep.edu.missionutils.test.Assertions.assertRandomNumberInRangeTest;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+
+class BridgeGameTest {
+    private static final String SELECTION_UP = "U";
+    private static final int SELECTION_UP_NUMBER = 1;
+    private static final String SELECTION_DOWN = "D";
+    private static final int SELECTION_DOWN_NUMBER = 0;
+    @DisplayName("잘못된 발판을 밟았을 때 죽는지 확인")
+    @Test
+    void 잘못_움직여_사망() {
+        assertRandomNumberInRangeTest(() -> {
+            BridgeGame bridgeGame = new BridgeGame(3);
+            bridgeGame.move(SELECTION_DOWN);
+
+            assertThat(bridgeGame.isPlayerDead()).isTrue();
+        }, SELECTION_UP_NUMBER, SELECTION_DOWN_NUMBER, SELECTION_DOWN_NUMBER);
+
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/bridge/Model/BridgeTest.java b/src/test/java/bridge/Model/BridgeTest.java
new file mode 100644
index 00000000000..1010d33bc3b
--- /dev/null
+++ b/src/test/java/bridge/Model/BridgeTest.java
@@ -0,0 +1,43 @@
+package bridge.Model;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+
+
+class BridgeTest {
+    private static final String ERROR = "[ERROR]";
+    private static final int MIN_RANGE = 3;
+    private static final int MAX_RANGE = 20;
+
+
+    @DisplayName("범위 외의 숫자 입력 시 예외 throw")
+    @ParameterizedTest
+    @ValueSource(ints = {1, 2, 55, 101})
+    void 예외_범위를_벗어난_숫자(int size) {
+        assertThatThrownBy(() -> assertThat(new Bridge(size)))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @DisplayName("범위 외의 숫자 입력 시 예외 메세지 확인")
+    @ParameterizedTest
+    @ValueSource(ints = {1, 2, 55, 101})
+    void 에러_범위를_벗어난_숫자(int size) {
+        assertThatThrownBy(() -> assertThat(new Bridge(size)))
+                .hasMessageContaining(ERROR);
+    }
+
+    @DisplayName("범위 내의 숫자가 예외를 발생하지 않는지 확인")
+    @ParameterizedTest
+    @ValueSource(ints = {MIN_RANGE, 5, MAX_RANGE})
+    void 입력_범위_내의_숫자(int size) {
+        assertDoesNotThrow(() -> new Bridge(size));
+
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/bridge/Util/InputConverterTest.java b/src/test/java/bridge/Util/InputConverterTest.java
new file mode 100644
index 00000000000..58b0fece9fe
--- /dev/null
+++ b/src/test/java/bridge/Util/InputConverterTest.java
@@ -0,0 +1,42 @@
+package bridge.Util;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+
+
+class InputConverterTest {
+    private static final String ERROR = "[ERROR]";
+
+    @DisplayName("정상적인 값의 문자열을 정수로 변환하는지 확인")
+    @ParameterizedTest
+    @ValueSource(strings = {"12", "1", "5", "4", "10"})
+    void 문자열을_정수로_변환(String input) {
+        int convertedNumber = InputConverter.convertToInt(input);
+        int expectedNumber = Integer.parseInt(input);
+
+        assertThat(convertedNumber).isEqualTo(expectedNumber);
+    }
+
+    @DisplayName("잘못된 입력값이 예외를 던지는지 확인")
+    @ParameterizedTest
+    @ValueSource(strings = {" ", "", "1a", "1,0"})
+    void 예외_정수_변환(String input) {
+        assertThatThrownBy(() ->
+                InputConverter.convertToInt((input)))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @DisplayName("잘못된 입력값에 대해 [Error]를 포함한 예외 메세지를 던지는지 확인")
+    @ParameterizedTest
+    @ValueSource(strings = {" ", "", "1a", "1,0"})
+    void 에러_정수_변환(String input) {
+        assertThatThrownBy(() ->
+                InputConverter.convertToInt((input)))
+                .hasMessageContaining(ERROR);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/bridge/Util/InputValidatorTest.java b/src/test/java/bridge/Util/InputValidatorTest.java
new file mode 100644
index 00000000000..c6ce7ef7703
--- /dev/null
+++ b/src/test/java/bridge/Util/InputValidatorTest.java
@@ -0,0 +1,45 @@
+package bridge.Util;
+
+import bridge.Constant.InputValue;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+
+
+class InputValidatorTest {
+    @DisplayName("잘못된 위, 아래 입력 예외 throw")
+    @ParameterizedTest
+    @ValueSource(strings = {"aaa", "bb", "d", "u", "", " "})
+    void validateSelectionInput(String input) {
+        assertThatThrownBy(() -> InputValidator.validateSelectionInput(input))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @DisplayName("올바른 위, 아래 입력 체크")
+    @ParameterizedTest
+    @ValueSource(strings = {InputValue.SELECTION_DOWN, InputValue.SELECTION_UP})
+    void assignSelectionInput(String input) {
+        assertDoesNotThrow(() -> InputValidator.validateSelectionInput(input));
+    }
+
+    @DisplayName("잘못된 재시작/종료 명령어 입력 예외 throw")
+    @ParameterizedTest
+    @ValueSource(strings = {"aaa", "bb", "d1", "5", "", " ", "Q3", "3Q"})
+    void validateCommandInput(String input) {
+        assertThatThrownBy(() -> InputValidator.validateCommandInput(input))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @DisplayName("올바른 재시작/종료 명령어 체크")
+    @ParameterizedTest
+    @ValueSource(strings = {InputValue.COMMAND_QUIT, InputValue.COMMAND_RETRY})
+    void assignCommandInput(String input) {
+        assertDoesNotThrow(() -> InputValidator.validateCommandInput(input));
+    }
+}
\ No newline at end of file