diff --git a/README.md b/README.md
index b4b1377..c8fcbd4 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,22 @@
 # 미션 - 워들
 
+## 📝 기능 목록
+
+### 코틀린 워들 기능목록 / 페퍼, 조조그린
+
+- [x] 시작메시지 출력하는 기능
+- [x] 답안을 입력받는 기능
+  - [x] 입력값은 5자리 문자열로 제한하는 기능
+  - [x] 입력값은 `words.txt` 에 존재하는 단어만 가능
+  - [x] 답안은 6번 만 입력 가능
+- [x] 오늘의 정답을 선택하는 기능
+    - [x] 정답은 `words.txt` 의 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어
+- [x] 답안이 각 문자가 정답의 문자와 어떻게 매칭되는지 찾는 기능
+    - [x] 두 개의 동일한 문자를 입력하고 그중 하나가 회색으로 표시되면 해당 문자 중 하나만 최종 단어에 표시
+- [x] 확인된 정보에 맞게 출력하는 기능
+    - [x] 맞는 글자는 초록색, 위치가 틀리면 노란색, 없으면 회색으로 표시
+- [x] 게임 결과를 출력하는 기능
+
 ## 🔍 진행 방식
 
 - 미션은 **기능 요구 사항, 프로그래밍 요구 사항, 과제 진행 요구 사항** 세 가지로 구성되어 있다.
diff --git a/src/main/kotlin/.gitkeep b/src/main/kotlin/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/main/kotlin/Application.kt b/src/main/kotlin/Application.kt
new file mode 100644
index 0000000..bd12ffe
--- /dev/null
+++ b/src/main/kotlin/Application.kt
@@ -0,0 +1,5 @@
+import wordle.controller.WordleController
+
+fun main() {
+    WordleController().run()
+}
diff --git a/src/main/kotlin/wordle/controller/WordleController.kt b/src/main/kotlin/wordle/controller/WordleController.kt
new file mode 100644
index 0000000..a7c090c
--- /dev/null
+++ b/src/main/kotlin/wordle/controller/WordleController.kt
@@ -0,0 +1,33 @@
+package wordle.controller
+
+import wordle.domain.Answer
+import wordle.domain.Game
+import wordle.domain.Words
+import wordle.view.printErrorMessage
+import wordle.view.printResults
+import wordle.view.printStartMessage
+import wordle.view.requestInput
+import java.time.LocalDate
+
+class WordleController {
+
+    fun run() {
+        val game = Game(Words.pick(LocalDate.now()))
+        printStartMessage(game.fixedCount)
+
+        while (game.isPlaying) {
+            val answer = requestAnswer()
+            game.playRound(answer)
+            printResults(game.results, game.isPlaying, game.findTryCount(), game.fixedCount)
+        }
+    }
+
+    private fun requestAnswer(): Answer {
+        return try {
+            Answer(requestInput())
+        } catch (e: IllegalArgumentException) {
+            printErrorMessage(e.message)
+            requestAnswer()
+        }
+    }
+}
diff --git a/src/main/kotlin/wordle/domain/Answer.kt b/src/main/kotlin/wordle/domain/Answer.kt
new file mode 100644
index 0000000..e935fc8
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/Answer.kt
@@ -0,0 +1,46 @@
+package wordle.domain
+
+class Answer(private val answer: String) {
+
+    init {
+        require(answer.length == WORD_SIZE) { "[ERROR] 부적절한 글자 길이입니다." }
+        require(Words.contains(answer)) { "[ERROR] 목록에 존재하지 않는 단어입니다." }
+    }
+
+    fun compareToWord(word: String): MutableList<Mark> {
+        val result = MutableList(WORD_SIZE) { Mark.NONE }
+        val wordTable = createWordTable(word)
+        (0 until WORD_SIZE).map { markExact(it, word, result, wordTable) }
+        (0 until WORD_SIZE).map { markExist(it, result, wordTable) }
+        return result
+    }
+
+    private fun createWordTable(word: String): HashMap<Char, Int> {
+        val wordTable = HashMap<Char, Int>()
+        for (char in word) {
+            wordTable[char] = wordTable.getOrDefault(char, 0) + 1
+        }
+        return wordTable
+    }
+
+    private fun markExact(i: Int, word: String, result: MutableList<Mark>, wordTable: HashMap<Char, Int>) {
+        if (word[i] == answer[i]) {
+            result[i] = Mark.EXACT
+            wordTable.computeIfPresent(word[i]) { _, v -> v - 1 }
+        }
+    }
+
+    private fun markExist(i: Int, result: MutableList<Mark>, wordTable: HashMap<Char, Int>) {
+        if (isExist(i, result, wordTable, answer[i])) {
+            result[i] = Mark.EXIST
+            wordTable.computeIfPresent(answer[i]) { _, v -> v - 1 }
+        }
+    }
+
+    private fun isExist(
+        i: Int,
+        result: MutableList<Mark>,
+        wordTable: HashMap<Char, Int>,
+        charOfAnswer: Char,
+    ) = result[i] == Mark.NONE && wordTable.containsKey(charOfAnswer) && wordTable[charOfAnswer] != 0
+}
diff --git a/src/main/kotlin/wordle/domain/Game.kt b/src/main/kotlin/wordle/domain/Game.kt
new file mode 100644
index 0000000..3e3c3b6
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/Game.kt
@@ -0,0 +1,21 @@
+package wordle.domain
+
+class Game(private val word: String) {
+    val fixedCount = 6
+    val results: Results = Results()
+    var isPlaying: Boolean = true
+        private set
+
+    fun playRound(answer: Answer) {
+        val result = answer.compareToWord(word)
+        results.add(result)
+        isPlaying = !isOver(result)
+    }
+
+    private fun isOver(result: MutableList<Mark>) =
+        results.isLimit() || result.all { it == Mark.EXACT }
+
+    fun findTryCount(): Int {
+        return results.value.size
+    }
+}
diff --git a/src/main/kotlin/wordle/domain/Mark.kt b/src/main/kotlin/wordle/domain/Mark.kt
new file mode 100644
index 0000000..9922112
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/Mark.kt
@@ -0,0 +1,8 @@
+package wordle.domain
+
+enum class Mark {
+
+    NONE,
+    EXIST,
+    EXACT
+}
diff --git a/src/main/kotlin/wordle/domain/Results.kt b/src/main/kotlin/wordle/domain/Results.kt
new file mode 100644
index 0000000..211a3e9
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/Results.kt
@@ -0,0 +1,16 @@
+package wordle.domain
+
+private const val LIMIT_SIZE = 6
+
+class Results {
+
+    val value: MutableList<List<Mark>> = mutableListOf()
+
+    fun add(result: List<Mark>) {
+        value.add(result)
+    }
+
+    fun isLimit(): Boolean {
+        return value.size >= LIMIT_SIZE
+    }
+}
diff --git a/src/main/kotlin/wordle/domain/Words.kt b/src/main/kotlin/wordle/domain/Words.kt
new file mode 100644
index 0000000..f30e24a
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/Words.kt
@@ -0,0 +1,23 @@
+package wordle.domain
+
+import java.io.File
+import java.time.LocalDate
+import java.time.temporal.ChronoUnit
+
+const val WORD_SIZE = 5
+
+object Words {
+
+    private val VALUE: List<String> = File("src/main/resources/words.txt").readLines()
+
+    private val BASIC_DATE = LocalDate.of(2021, 6, 19)
+
+    fun contains(word: String): Boolean {
+        return VALUE.contains(word)
+    }
+
+    fun pick(date: LocalDate): String {
+        val index = ChronoUnit.DAYS.between(BASIC_DATE, date) % VALUE.size
+        return VALUE[index.toInt()]
+    }
+}
diff --git a/src/main/kotlin/wordle/view/View.kt b/src/main/kotlin/wordle/view/View.kt
new file mode 100644
index 0000000..8e2f60c
--- /dev/null
+++ b/src/main/kotlin/wordle/view/View.kt
@@ -0,0 +1,44 @@
+package wordle.view
+
+import wordle.domain.Mark
+import wordle.domain.Results
+
+fun printStartMessage(fixedCount: Int) {
+    println("WORDLE 을 $fixedCount 번 만에 맞춰 보세요.\n시도의 결과는 타일의 색 변화로 나타납니다.")
+}
+
+fun requestInput(): String {
+    println("정답을 입력해 주세요.")
+    return readln()
+}
+
+fun printResults(results: Results, isPlaying: Boolean, tryCount: Int, fixedCount: Int) {
+    println()
+    if (!isPlaying) {
+        printTryCount(tryCount, fixedCount)
+    }
+    results.value.forEach {
+        printResult(it)
+    }
+    println()
+}
+
+fun printTryCount(tryCount: Int, fixedCount: Int) {
+    println("$tryCount/$fixedCount\n")
+}
+
+private fun printResult(result: List<Mark>) {
+    val stringBuilder = StringBuilder()
+    result.forEach {
+        when (it) {
+            Mark.NONE -> stringBuilder.append("⬜")
+            Mark.EXIST -> stringBuilder.append("🟨")
+            Mark.EXACT -> stringBuilder.append("🟩")
+        }
+    }
+    println(stringBuilder.toString())
+}
+
+fun printErrorMessage(message: String?) {
+    println(message)
+}
diff --git a/src/test/kotlin/.gitkeep b/src/test/kotlin/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/test/kotlin/practice/DslTest.kt b/src/test/kotlin/practice/DslTest.kt
new file mode 100644
index 0000000..a377eba
--- /dev/null
+++ b/src/test/kotlin/practice/DslTest.kt
@@ -0,0 +1,51 @@
+package practice
+
+import org.assertj.core.api.AssertionsForInterfaceTypes.assertThat
+import org.junit.jupiter.api.Test
+
+class DslTest {
+
+    @Test
+    fun `자기소개 프러퍼티 버전`() {
+        val person = introduce {
+            name = "최수연"
+            age = 26
+        }
+        assertThat(person.name).isEqualTo("최수연")
+        assertThat(person.age).isEqualTo(26)
+    }
+
+    @Test
+    fun `자기소개 함수 버전`() {
+        val person = introduce {
+            name("최수연")
+            age(26)
+        }
+        assertThat(person.name).isEqualTo("최수연")
+        assertThat(person.age).isEqualTo(26)
+    }
+}
+
+private fun introduce(builder: PersonBuilder.() -> Unit): Person {
+// 람다에서 함수 형식을 지정가능
+    return PersonBuilder().apply(builder).build()
+}
+
+class PersonBuilder {
+    lateinit var name: String
+    var age: Int = 0
+
+    fun name(value: String) {
+        name = value
+    }
+
+    fun age(value: Int) {
+        age = value
+    }
+
+    fun build(): Person {
+        return Person(name, age)
+    }
+}
+
+data class Person(val name: String, val age: Int)
diff --git a/src/test/kotlin/study/DslTest.kt b/src/test/kotlin/study/DslTest.kt
new file mode 100644
index 0000000..2a9b3b3
--- /dev/null
+++ b/src/test/kotlin/study/DslTest.kt
@@ -0,0 +1,82 @@
+package study
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.groups.Tuple
+import org.junit.jupiter.api.Test
+
+class DslTest {
+    @Test
+    fun `페퍼 자기소개 프러퍼티 버전`() {
+        val profile = introduce {
+            name("최수연")
+            company("우아한테크코스")
+            skills {
+                soft("A passion for problem solving")
+                soft("Good communication skills")
+                hard("Kotlin")
+            }
+            languages {
+                "Korean" level 5
+                "English" level 3
+            }
+        }
+        assertThat(profile.name).isEqualTo("최수연")
+        assertThat(profile.company).isEqualTo("우아한테크코스")
+        assertThat(profile.skills.soft).contains("A passion for problem solving", "Good communication skills")
+        assertThat(profile.skills.hard).contains("Kotlin")
+        assertThat(profile.languages.languages).extracting("type", "level")
+            .contains(
+                Tuple.tuple("Korean", 5),
+                Tuple.tuple("English", 3)
+            )
+    }
+}
+
+fun introduce(builder: ProfileBuilder.() -> Unit): Profile {
+    return ProfileBuilder().apply(builder).build()
+}
+
+class ProfileBuilder {
+    private lateinit var name: String
+    private lateinit var company: String
+    private lateinit var skills: Skills
+    private lateinit var languages: Languages
+
+    fun name(value: String) {
+        name = value
+    }
+
+    fun company(value: String) {
+        company = value
+    }
+
+    fun skills(skillValue: Skills.() -> Unit) {
+        skills = Skills(mutableListOf(), mutableListOf()).apply(skillValue)
+    }
+
+    fun languages(languageSkill: Languages.() -> Unit) {
+        languages = Languages(mutableListOf()).apply(languageSkill)
+    }
+
+    fun build(): Profile {
+        return Profile(name, company, skills, languages)
+    }
+}
+
+data class Profile(val name: String, val company: String, val skills: Skills, val languages: Languages)
+
+data class Skills(val hard: MutableList<String>, val soft: MutableList<String>) {
+    fun hard(value: String) {
+        hard.add(value)
+    }
+
+    fun soft(value: String) {
+        soft.add(value)
+    }
+}
+
+data class Languages(val languages: MutableList<Language>) {
+    infix fun String.level(value: Int) = languages.add(Language(this, value))
+}
+
+data class Language(val type: String, val level: Int)
diff --git a/src/test/kotlin/wordle/domain/AnswerTest.kt b/src/test/kotlin/wordle/domain/AnswerTest.kt
new file mode 100644
index 0000000..1acc62b
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/AnswerTest.kt
@@ -0,0 +1,92 @@
+package wordle.domain
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.data.forAll
+import io.kotest.data.headers
+import io.kotest.data.row
+import io.kotest.data.table
+import io.kotest.matchers.collections.shouldContainExactly
+import io.kotest.matchers.throwable.shouldHaveMessage
+import org.junit.jupiter.api.Test
+import wordle.domain.Mark.EXACT
+import wordle.domain.Mark.EXIST
+import wordle.domain.Mark.NONE
+
+internal class AnswerTest {
+
+    @Test
+    fun `글자길이가 5가 아닌 경우 예외발생`() {
+        forAll(
+            table(
+                headers("answer"),
+                row("abcd"),
+                row("abcdef")
+            )
+        ) {
+            shouldThrow<IllegalArgumentException> { Answer(it) }
+                .shouldHaveMessage("[ERROR] 부적절한 글자 길이입니다.")
+        }
+    }
+
+    @Test
+    fun `주어진 단어목록에 존재하지 않는 경우 예외발생`() {
+        shouldThrow<IllegalArgumentException> { Answer("abcde") }
+            .shouldHaveMessage("[ERROR] 목록에 존재하지 않는 단어입니다.")
+    }
+
+    @Test
+    fun `답안과 정답이 일치`() {
+        val answer = Answer("apple")
+
+        answer.compareToWord("apple") shouldContainExactly listOf(EXACT, EXACT, EXACT, EXACT, EXACT)
+    }
+
+    @Test
+    fun `정답과 답안의 문자가 모두 불일치`() {
+        val answer = Answer("madam")
+
+        answer.compareToWord("rerun") shouldContainExactly listOf(NONE, NONE, NONE, NONE, NONE)
+    }
+
+    @Test
+    fun `정답의 문자가 답안에 모두 존재하지만 위치가 모두 불일치`() {
+        val answer = Answer("rebut")
+
+        answer.compareToWord("brute") shouldContainExactly listOf(EXIST, EXIST, EXIST, EXIST, EXIST)
+    }
+
+    @Test
+    fun `정답이 rebut이고 답안이 speed일 때 첫번째 e만 EXIST, 나머지는 NONE`() {
+        val answer = Answer("speed")
+
+        answer.compareToWord("rebut") shouldContainExactly listOf(NONE, NONE, EXIST, NONE, NONE)
+    }
+
+    @Test
+    fun `정답이 erase이고 답안이 speed일 때 e와 s는 모두 EXIST, 나머지는 NONE`() {
+        val answer = Answer("speed")
+
+        answer.compareToWord("erase") shouldContainExactly listOf(EXIST, NONE, EXIST, EXIST, NONE)
+    }
+
+    @Test
+    fun `정답이 spill이고 답안이 label일 때 첫번째 l은 EXIST, 두번째 l은 EXACT, 나머지는 NONE`() {
+        val answer = Answer("label")
+
+        answer.compareToWord("spill") shouldContainExactly listOf(EXIST, NONE, NONE, NONE, EXACT)
+    }
+
+    @Test
+    fun `정답이 spill이고 답안이 hello일 때 첫번째 l은 EXIST, 두번째 l은 EXACT, 나머지는 NONE`() {
+        val answer = Answer("hello")
+
+        answer.compareToWord("spill") shouldContainExactly listOf(NONE, NONE, EXIST, EXACT, NONE)
+    }
+
+    @Test
+    fun `정답이 mourn이고 답안이 sorry일 때 o와 두번째 r은 EXACT, 나머지는 NONE`() {
+        val answer = Answer("sorry")
+
+        answer.compareToWord("mourn") shouldContainExactly listOf(NONE, EXACT, NONE, EXACT, NONE)
+    }
+}
diff --git a/src/test/kotlin/wordle/domain/GameTest.kt b/src/test/kotlin/wordle/domain/GameTest.kt
new file mode 100644
index 0000000..f5602ce
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/GameTest.kt
@@ -0,0 +1,50 @@
+package wordle.domain
+
+import io.kotest.assertions.assertSoftly
+import io.kotest.matchers.ints.shouldBeExactly
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+internal class GameTest {
+
+    @Test
+    fun `정답을 6번 미만으로 입력한 경우 게임 진행 가능`() {
+        val game = Game("fetus")
+        repeat(5) { game.playRound(Answer("apple")) }
+
+        assertSoftly(game) {
+            findTryCount() shouldBeExactly 5
+            isPlaying shouldBe true
+        }
+    }
+
+    @Test
+    fun `게임을 한 라운드씩 진행하다 6라운드에 도달하면 게임종료`() {
+        val game = Game("fetus")
+        repeat(6) { game.playRound(Answer("apple")) }
+
+        assertSoftly(game) {
+            findTryCount() shouldBeExactly 6
+            isPlaying shouldBe false
+        }
+    }
+
+    @Test
+    fun `게임 6라운드 이전에 정답을 맞추면 게임종료`() {
+        val game = Game("fetus")
+        repeat(3) { game.playRound(Answer("fetus")) }
+
+        assertSoftly(game) {
+            findTryCount() shouldBeExactly 3
+            isPlaying shouldBe false
+        }
+    }
+
+    @Test
+    fun `몇번째 시도인지 계산`() {
+        val game = Game("fetus")
+        repeat(6) { game.playRound(Answer("apple")) }
+
+        game.findTryCount() shouldBeExactly 6
+    }
+}
diff --git a/src/test/kotlin/wordle/domain/WordsTest.kt b/src/test/kotlin/wordle/domain/WordsTest.kt
new file mode 100644
index 0000000..174adc2
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/WordsTest.kt
@@ -0,0 +1,15 @@
+package wordle.domain
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import java.time.LocalDate
+
+internal class WordsTest {
+
+    @Test
+    fun `오늘의 단어를 선택`() {
+        val date = LocalDate.of(2022, 5, 12)
+
+        Words.pick(date) shouldBe "fetus"
+    }
+}