diff --git a/README.md b/README.md
index af0309a9e..b0b40bbd9 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Duke project template
+# Growler project template
 
 This is a project template for a greenfield Java project. It's named after the Java mascot _Duke_. Given below are instructions on how to use it.
 
@@ -13,7 +13,7 @@ Prerequisites: JDK 17, update Intellij to the most recent version.
    1. If there are any further prompts, accept the defaults.
 1. Configure the project to use **JDK 17** (not other versions) as explained in [here](https://www.jetbrains.com/help/idea/sdk.html#set-up-jdk).<br>
    In the same dialog, set the **Project language level** field to the `SDK default` option.
-1. After that, locate the `src/main/java/Duke.java` file, right-click it, and choose `Run Duke.main()` (if the code editor is showing compile errors, try restarting the IDE). If the setup is correct, you should see something like the below as the output:
+1. After that, locate the `src/main/java/Growler.java` file, right-click it, and choose `Run Growler.main()` (if the code editor is showing compile errors, try restarting the IDE). If the setup is correct, you should see something like the below as the output:
    ```
    Hello from
     ____        _        
diff --git a/data/Growler.txt b/data/Growler.txt
new file mode 100644
index 000000000..67161d824
--- /dev/null
+++ b/data/Growler.txt
@@ -0,0 +1,2 @@
+T | 0 | return book
+T | 0 | return book
diff --git a/docs/README.md b/docs/README.md
index 47b9f984f..bd931e9dd 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,30 +1,96 @@
-# Duke User Guide
+# Growler Project
+**A Java-based CLI task management assistant**
 
-// Update the title above to match the actual product name
+---
 
-// Product screenshot goes here
+## **Introduction**
+**Growler** is a simple and interactive **command-line chatbot** that helps you manage your daily tasks efficiently. You can add different types of tasks, mark them as done, and list them in an organized manner. Growler is built using Java and adopts a step by step development process.
 
-// Product intro goes here
+---
 
-## Adding deadlines
+### **Features**
+- **Task Management**
+    - **ToDo**: Simple tasks without a date (e.g., `todo read book`)
+    - **Deadline**: Tasks with a due date (e.g., `deadline submit assignment /by Sunday`)
+    - **Event**: Tasks with a start and end time (e.g., `event group meeting /from 9pm /to 11pm`)
+- **Task Completion**
+    - Mark tasks as done (`mark 2`) or not done (`unmark 2`), according to the index of the task 
+- **Task Search** 
+    - Finds and displays all tasks which contains a keyword (e.g., `find book`)
+- **Task Deletion**
+    - Deletes task according to its index (e.g., `delete 2`)
+- **Task Listing**
+    - View all added tasks (`list`)
+- **User-friendly CLI**
+    - Growler interacts with users through an easy-to-use command-line interface.
 
-// Describe the action and its outcome.
+---
 
-// Give examples of usage
+## **Setting Up in IntelliJ IDEA**
+### **Prerequisites**
+- **JDK 17** (Ensure Java 17 is installed)
+- **Latest version of IntelliJ IDEA**
 
-Example: `keyword (optional arguments)`
+### **Installation Steps**
+1. **Open IntelliJ IDEA**
+    - If a project is already open, go to `File` > `Close Project` to return to the welcome screen.
 
-// A description of the expected outcome goes here
+2. **Import the Project**
+    - Click **Open**
+    - Select the project directory
+    - Click **OK** and accept all default settings.
 
-```
-expected output
-```
+3. **Set up the correct JDK**
+    - Go to **`File` > `Project Structure` > `Project`**
+    - Set **Project SDK** to `JDK 17`
+    - Set **Project language level** to `SDK default`
+    - Click `Apply` and `OK`
 
-## Feature ABC
+4. **Run Growler**
+    - Navigate to `src/main/java/Istella.java`
+    - Right-click on `Growler.java`, select **Run 'Growler'**
+    - If everything is set up correctly, you should see the following output:
 
-// Feature details
+Hello! I'm Growler
 
+What can I do for you?
 
-## Feature XYZ
 
-// Feature details
\ No newline at end of file
+---
+
+## **Usage Guide**
+Here are some example commands to interact with Growler:
+
+| **Command**                            | **Description**                    | **Example**                              |
+|----------------------------------------|------------------------------------|------------------------------------------|
+| `todo <task>`                          | Adds a **ToDo** task               | `todo buy milk`                          |
+| `deadline <task> /by <date>`           | Adds a **Deadline** task           | `deadline project submission /by Sunday` |
+| `event <task> /from <start> /to <end>` | Adds an **Event** task             | `event concert /from 6pm /to 10pm`       |
+| `list`                                 | Displays all added tasks           | `list`                                   |
+| `mark <task number>`                   | Marks a task as done               | `mark 2`                                 |
+| `unmark <task number>`                 | Marks a task as not done           | `unmark 2`                               |
+| `delete <task number>`                 | Deletes task specified index       | `delete 2`                               |
+| `find <keyword>`                       | Finds all tasks containing keyword | `find book`                              |
+| `bye`                                  | Exits Growler                      | `bye`                                    |
+
+
+## **Important Notes**
+- **Keep all Java files inside `src/main/java/`**
+    - Do not rename or move this directory, as tools like Gradle rely on it.
+- **Use Java 17**
+    - Running the project with a different Java version may cause compatibility issues.
+
+---
+
+## **Further Enhancements**
+- Implement **reminders** (reminds user of task deadlines/upcoming events)
+- Implement **Categorization of tasks** (Categorizes based on work/personal/family/etc) 
+- Implement **graphical user interface (GUI)** using JavaFX
+
+---
+
+## **Contributing**
+Feel free to contribute by:
+- Forking the repository
+- Adding feature branches
+- Submitting pull requests
\ No newline at end of file
diff --git a/src/main/java/Deadline.java b/src/main/java/Deadline.java
new file mode 100644
index 000000000..0937ab102
--- /dev/null
+++ b/src/main/java/Deadline.java
@@ -0,0 +1,39 @@
+/**
+ * Represents a task with a deadline.
+ * A Deadline task has a name and a due date, in addition to the standard task properties.
+ */
+public class Deadline extends Task {
+    protected String dueDate;
+
+    /**
+     * Constructs a Deadline task with the specified task name and due date.
+     *
+     * @param taskName The name of the task.
+     * @param dueDate  The due date of the task.
+     */
+    public Deadline(String taskName, String dueDate) {
+        super(taskName);
+        this.dueDate = dueDate;
+    }
+
+    /**
+     * Returns a string representation of the Deadline task, including its type,
+     * task name, and due date.
+     *
+     * @return A formatted string representing the Deadline task.
+     */
+    @Override
+    public String toString() {
+        return "[D]" + super.toString() + " (by: " + dueDate + ")";
+    }
+
+    /**
+     * Returns the Deadline task in a format suitable for file storage.
+     *
+     * @return A formatted string representing the Deadline task for saving to a file.
+     */
+    @Override
+    public String toFileFormat() {
+        return "D | " + (isDone ? "1" : "0") + " | " + taskName + " | " + dueDate;
+    }
+}
diff --git a/src/main/java/Duke.java b/src/main/java/Duke.java
deleted file mode 100644
index 5d313334c..000000000
--- a/src/main/java/Duke.java
+++ /dev/null
@@ -1,10 +0,0 @@
-public class Duke {
-    public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
-    }
-}
diff --git a/src/main/java/Event.java b/src/main/java/Event.java
new file mode 100644
index 000000000..d3a790f49
--- /dev/null
+++ b/src/main/java/Event.java
@@ -0,0 +1,43 @@
+/**
+ * The Event class represents a task that occurs between a start date and an end date.
+ * It extends the Task class and adds fields for the event's start and end dates.
+ */
+public class Event extends Task {
+    protected String startDate;
+    protected String endDate;
+
+    /**
+     * Constructs an Event with the specified task name, start date, and end date.
+     *
+     * @param taskName The name of the task.
+     * @param startDate The start date of the event.
+     * @param endDate The end date of the event.
+     */
+    public Event(String taskName, String startDate, String endDate) {
+        super(taskName);
+        this.startDate = startDate;
+        this.endDate = endDate;
+    }
+
+    /**
+     * Returns a string representation of the Event task.
+     * The format is "[E] <taskName> (from: <startDate> to: <endDate>)".
+     *
+     * @return A string representing the Event task in the specified format.
+     */
+    @Override
+    public String toString(){
+        return "[E]" + super.toString() + " (from: " + startDate + " to: " + endDate + ")";
+    }
+
+    /**
+     * Returns the Event task in a format suitable for saving to a file.
+     * The format is "E | <isDone> | <taskName> | <startDate> | <endDate>".
+     *
+     * @return A string representing the Event task in a file-friendly format.
+     */
+    @Override
+    public String toFileFormat() {
+        return "E | " + (isDone ? "1" : "0") + " | " + taskName + " | " + startDate + " | " + endDate;
+    }
+}
diff --git a/src/main/java/Growler.java b/src/main/java/Growler.java
new file mode 100644
index 000000000..d155ea829
--- /dev/null
+++ b/src/main/java/Growler.java
@@ -0,0 +1,41 @@
+import java.util.Scanner;
+
+/**
+ * The Growler class is the main entry point for the Growler application.
+ * It initializes the necessary components (Storage, Ui, Parser, TaskList) and processes user commands.
+ * The program runs in a loop until the user types "bye", handling task management operations.
+ */
+public class Growler {
+
+    /**
+     * The main method starts the Growler application and processes user commands.
+     * It initializes the storage, UI, parser, and task list, then enters a loop to process commands.
+     * The loop continues until the user types "bye".
+     *
+     * @param args Command-line arguments (not used in this application).
+     * @throws GrowlerException If there is an error while handling tasks (e.g., invalid task format).
+     */
+    public static void main(String[] args) throws GrowlerException {
+        Storage storage = new Storage();
+        Ui ui = new Ui();
+        Parser parser = new Parser();
+        Task[] tasks = new Task[100];
+        int taskCount = storage.loadTasks(tasks);  // Load existing tasks from storage
+        TaskList taskList = new TaskList(tasks, taskCount);
+        ui.showWelcomeMessage();
+        Scanner in = new Scanner(System.in);
+        while (true) {
+            String userInput = in.nextLine();  // Get user input
+            if (userInput.equals("bye")) {
+                ui.showGoodbyeMessage();
+                break;
+            }
+            try {
+                parser.handleCommand(userInput, taskList, storage, ui);
+            } catch (GrowlerException e) {
+                ui.showError(e.getMessage());
+            }
+        }
+        in.close();
+    }
+}
diff --git a/src/main/java/GrowlerException.java b/src/main/java/GrowlerException.java
new file mode 100644
index 000000000..55e96c1e2
--- /dev/null
+++ b/src/main/java/GrowlerException.java
@@ -0,0 +1,15 @@
+/**
+ * The GrowlerException class is a custom exception used in the Growler application.
+ * It extends the {@link Exception} class and allows for handling specific errors that occur in the application.
+ */
+public class GrowlerException extends Exception {
+
+    /**
+     * Constructs a new GrowlerException with the specified detail message.
+     *
+     * @param message The detail message to describe the exception.
+     */
+    public GrowlerException(String message) {
+        super(message);
+    }
+}
diff --git a/src/main/java/META-INF/MANIFEST.MF b/src/main/java/META-INF/MANIFEST.MF
new file mode 100644
index 000000000..9d384945c
--- /dev/null
+++ b/src/main/java/META-INF/MANIFEST.MF
@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: Growler
+
diff --git a/src/main/java/Parser.java b/src/main/java/Parser.java
new file mode 100644
index 000000000..ed7b53384
--- /dev/null
+++ b/src/main/java/Parser.java
@@ -0,0 +1,151 @@
+/**
+ * The Parser class handles user commands for managing tasks.
+ * It processes various commands such as marking, unmarking, deleting tasks,
+ * adding tasks (to-do, deadline, event), and searching tasks.
+ */
+public class Parser {
+
+    /**
+     * Handles the user input command and delegates the corresponding task action.
+     *
+     * @param userInput The command entered by the user.
+     * @param taskList The task list to manipulate.
+     * @param storage The storage for saving tasks.
+     * @param ui The user interface for displaying results.
+     * @throws GrowlerException If an error occurs during command processing.
+     */
+    public void handleCommand(String userInput, TaskList taskList, Storage storage, Ui ui) throws GrowlerException {
+        if (userInput.startsWith("mark")) {
+            handleMarkCommand(userInput, true, taskList, storage, ui);
+        } else if (userInput.startsWith("unmark")) {
+            handleMarkCommand(userInput, false, taskList, storage, ui);
+        } else if (userInput.startsWith("delete")) {
+            handleDeleteCommand(userInput, taskList, storage, ui);
+        } else if (userInput.equals("list")) {
+            taskList.showTasks(ui);
+        } else if (userInput.startsWith("find")) {
+            handleFindCommand(userInput, taskList, ui);
+        } else {
+            handleAddTask(userInput, taskList, storage, ui);
+        }
+    }
+
+    /**
+     * Adds a new task based on the user input.
+     * Supports to-do, deadline, and event tasks.
+     *
+     * @param userInput The command entered by the user.
+     * @param taskList The task list to add the new task.
+     * @param storage The storage to save the updated task list.
+     * @param ui The user interface to display results.
+     * @throws GrowlerException If the task format is invalid.
+     */
+    private void handleAddTask(String userInput, TaskList taskList, Storage storage, Ui ui) throws GrowlerException {
+        Task newTask = null;
+        if (userInput.startsWith("todo")) {
+            String taskName = userInput.substring(4).trim();
+            if (taskName.isEmpty()) {
+                throw new GrowlerException("Please tell me what you need to do.");
+            }
+            newTask = new Todo(taskName);
+        } else if (userInput.startsWith("deadline")) {
+            String[] parts = userInput.substring(8).trim().split(" /by ", 2);
+            if (parts.length < 2 || parts[0].isEmpty() || parts[1].isEmpty()) {
+                throw new GrowlerException("Invalid format! Use: deadline <task> /by <time>");
+            }
+            newTask = new Deadline(parts[0].trim(), parts[1].trim());
+        } else if (userInput.startsWith("event")) {
+            String[] parts = userInput.substring(6).trim().split(" /from ", 2);
+            if (parts.length < 2 || !parts[1].contains(" /to ")) {
+                throw new GrowlerException("Invalid format! Use: event <task> /from <start> /to <end>");
+            }
+            String[] timeParts = parts[1].split(" /to ", 2);
+            newTask = new Event(parts[0].trim(), timeParts[0].trim(), timeParts[1].trim());
+        }
+        if (newTask != null) {
+            taskList.addTask(newTask);
+            ui.showTaskAdded(newTask, taskList.getTaskCount());
+            storage.saveTasks(taskList.tasks, taskList.getTaskCount());
+        } else {
+            throw new GrowlerException("Invalid task format. Please specify todo, deadline, or event.");
+        }
+    }
+
+    /**
+     * Marks or unmarks a task as done based on the user input.
+     *
+     * @param userInput The command entered by the user.
+     * @param isMark Whether to mark the task as done (true) or unmark it (false).
+     * @param taskList The task list to modify.
+     * @param storage The storage to save the updated task list.
+     * @param ui The user interface to display results.
+     * @throws GrowlerException If the task index is invalid.
+     */
+    private void handleMarkCommand(String userInput, boolean isMark, TaskList taskList, Storage storage, Ui ui) throws GrowlerException {
+        int taskIndex = getTaskIndex(userInput, taskList);
+        Task task = taskList.getTask(taskIndex);
+        if (isMark) {
+            task.markDone();
+            ui.showTaskMarked(task);
+        } else {
+            task.unmarkDone();
+            ui.showTaskUnmarked(task);
+        }
+        storage.saveTasks(taskList.tasks, taskList.getTaskCount());
+    }
+
+    /**
+     * Deletes a task based on the user input.
+     *
+     * @param userInput The command entered by the user.
+     * @param taskList The task list to delete the task from.
+     * @param storage The storage to save the updated task list.
+     * @param ui The user interface to display results.
+     * @throws GrowlerException If the task index is invalid.
+     */
+    private void handleDeleteCommand(String userInput, TaskList taskList, Storage storage, Ui ui) throws GrowlerException {
+        int taskIndex = getTaskIndex(userInput, taskList);
+        Task removedTask = taskList.getTask(taskIndex);
+        taskList.deleteTask(taskIndex);
+        ui.showTaskDeleted(removedTask, taskList.getTaskCount());
+        storage.saveTasks(taskList.tasks, taskList.getTaskCount());
+    }
+
+    /**
+     * Finds and displays tasks matching a keyword.
+     *
+     * @param userInput The command entered by the user.
+     * @param taskList The task list to search.
+     * @param ui The user interface to display results.
+     */
+    private void handleFindCommand(String userInput, TaskList taskList, Ui ui) {
+        String keyword = userInput.substring(4).trim();
+        if (keyword.isEmpty()) {
+            ui.showMessage("Please specify a keyword to search for.");
+        } else {
+            taskList.findTasks(keyword, ui);
+        }
+    }
+
+    /**
+     * Retrieves the task index from the user input.
+     *
+     * @param userInput The command entered by the user.
+     * @param taskList The task list to validate the index.
+     * @return The index of the task (0-based).
+     * @throws GrowlerException If the task index is invalid or the format is incorrect.
+     */
+    private int getTaskIndex(String userInput, TaskList taskList) throws GrowlerException {
+        try {
+            int taskIndex = Integer.parseInt(userInput.split(" ")[1]) - 1;
+            if (taskIndex < 0 || taskIndex >= taskList.getTaskCount()) {
+                throw new GrowlerException("Task number must be between 1 and " + taskList.getTaskCount() + ".");
+            }
+            return taskIndex;
+        } catch (NumberFormatException e) {
+            throw new GrowlerException("Invalid format! Task number must be an integer.");
+        } catch (ArrayIndexOutOfBoundsException e) {
+            throw new GrowlerException("Invalid format! Use: <command> <task number>");
+        }
+    }
+}
diff --git a/src/main/java/Storage.java b/src/main/java/Storage.java
new file mode 100644
index 000000000..82105fb32
--- /dev/null
+++ b/src/main/java/Storage.java
@@ -0,0 +1,111 @@
+import java.io.*;
+
+/**
+ * The Storage class handles reading and writing tasks to a file on disk.
+ * It ensures that tasks are saved persistently and loaded back when the program restarts.
+ */
+public class Storage {
+    private static final String FILE_PATH = "./data/Growler.txt";
+    private static final int MAX_TASKS = 100;
+
+    /**
+     * Constructs a Storage object and ensures that the necessary file and folder structure exists.
+     */
+    public Storage() {
+        ensureFileExists();
+    }
+
+    /**
+     * Ensures that the save file and its parent folder exist.
+     * If the folder or file does not exist, they are created.
+     */
+    private void ensureFileExists() {
+        File file = new File(FILE_PATH);
+        File folder = file.getParentFile();
+        try {
+            if (folder != null && !folder.exists()) {
+                folder.mkdirs(); // Create folder if missing
+            }
+            if (!file.exists()) {
+                file.createNewFile(); // Create file if missing
+            }
+        } catch (IOException e) {
+            System.out.println("Error creating save file: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Saves the current list of tasks to the file.
+     * Each task is written in a specific format defined by its `toFileFormat` method.
+     *
+     * @param taskList  The array of tasks to save.
+     * @param taskCount The number of tasks in the list.
+     */
+    public void saveTasks(Task[] taskList, int taskCount) {
+        try (BufferedWriter writer = new BufferedWriter(new FileWriter(FILE_PATH))) {
+            for (int i = 0; i < taskCount; i++) { // Only save valid tasks
+                writer.write(taskList[i].toFileFormat());
+                writer.newLine();
+            }
+        } catch (IOException e) {
+            System.out.println("Error saving tasks: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Loads tasks from the save file into the provided task array.
+     * Reads each line from the file and parses it into a Task object.
+     *
+     * @param taskList The array to store the loaded tasks.
+     * @return The number of tasks successfully loaded from the file.
+     */
+    public int loadTasks(Task[] taskList) {
+        int taskCount = 0;
+        try (BufferedReader reader = new BufferedReader(new FileReader(FILE_PATH))) {
+            String line;
+            while ((line = reader.readLine()) != null && taskCount < MAX_TASKS) {
+                Task task = parseTask(line);
+                if (task != null) {
+                    taskList[taskCount] = task;
+                    taskCount++;
+                }
+            }
+        } catch (IOException e) {
+            System.out.println("No previous task list found. Starting fresh!");
+        }
+        return taskCount;  // Returns taskCount, not Task[] array
+    }
+
+    /**
+     * Parses a single line from the save file into a Task object.
+     * Supports Todo, Deadline, and Event task types.
+     *
+     * @param line The line to parse.
+     * @return A Task object if the line is valid, or null if the format is invalid.
+     */
+    private Task parseTask(String line) {
+        try {
+            String[] parts = line.split(" \\| ");
+            String type = parts[0];
+            boolean isDone = parts[1].equals("1");
+            String description = parts[2];
+            Task task;
+            if (type.equals("T")) {
+                task = new Todo(description);
+            } else if (type.equals("D")) {
+                task = new Deadline(description, parts[3]);
+            } else if (type.equals("E")) {
+                task = new Event(description, parts[3], parts[4]);
+            } else {
+                return null; // Invalid format
+            }
+            if (isDone) {
+                task.markDone();
+            }
+            return task;
+        } catch (Exception e) {
+            System.out.println("Error parsing task: " + line);
+            return null;
+        }
+    }
+}
diff --git a/src/main/java/Task.java b/src/main/java/Task.java
new file mode 100644
index 000000000..3d6737c5b
--- /dev/null
+++ b/src/main/java/Task.java
@@ -0,0 +1,62 @@
+/**
+ * Represents a generic task with a name and a completion status.
+ */
+public class Task {
+    protected String taskName;
+    protected boolean isDone;
+
+    /**
+     * Constructs a task with the specified name.
+     * The task is initially marked as not done.
+     *
+     * @param taskName The name of the task.
+     */
+    public Task(String taskName) {
+        this.taskName = taskName;
+        this.isDone = false;
+    }
+
+    /**
+     * Retrieves the name of the task.
+     *
+     * @return The task name.
+     */
+    public String getTaskName() {
+        return taskName;
+    }
+
+    /**
+     * Marks the task as done.
+     */
+    public void markDone() {
+        this.isDone = true;
+    }
+
+    /**
+     * Marks the task as not done.
+     */
+    public void unmarkDone() {
+        this.isDone = false;
+    }
+
+    /**
+     * Returns a string representation of the task.
+     * The format includes the completion status and the task name.
+     *
+     * @return A formatted string representing the task.
+     */
+    @Override
+    public String toString() {
+        return (isDone ? "[X]" : "[ ]") + " " + taskName;
+    }
+
+    /**
+     * Converts the task to a file-friendly format for saving to storage.
+     * The format includes the task type, completion status, and task name.
+     *
+     * @return A formatted string suitable for file storage.
+     */
+    public String toFileFormat() {
+        return "T | " + (isDone ? "1" : "0") + " | " + taskName;
+    }
+}
diff --git a/src/main/java/TaskList.java b/src/main/java/TaskList.java
new file mode 100644
index 000000000..70edd3db3
--- /dev/null
+++ b/src/main/java/TaskList.java
@@ -0,0 +1,89 @@
+/**
+ * Manages a list of tasks, providing operations to add, retrieve, delete, and search tasks.
+ */
+public class TaskList {
+    protected Task[] tasks;
+    private int taskCount;
+
+    /**
+     * Constructs a TaskList with the specified array of tasks and the current task count.
+     *
+     * @param tasks     The array of tasks to initialize the TaskList.
+     * @param taskCount The initial count of tasks in the TaskList.
+     */
+    public TaskList(Task[] tasks, int taskCount) {
+        this.tasks = tasks;
+        this.taskCount = taskCount;
+    }
+
+    /**
+     * Adds a task to the list.
+     *
+     * @param task The task to add.
+     */
+    public void addTask(Task task) {
+        tasks[taskCount++] = task;
+    }
+
+    /**
+     * Retrieves a task at the specified index.
+     *
+     * @param index The index of the task to retrieve.
+     * @return The task at the specified index.
+     */
+    public Task getTask(int index) {
+        return tasks[index];
+    }
+
+    /**
+     * Deletes a task at the specified index.
+     * Shifts remaining tasks to fill the gap.
+     *
+     * @param index The index of the task to delete.
+     */
+    public void deleteTask(int index) {
+        Task removedTask = tasks[index];
+        System.arraycopy(tasks, index + 1, tasks, index, taskCount - index - 1);
+        tasks[--taskCount] = null;
+    }
+
+    /**
+     * Displays the list of tasks.
+     *
+     * @param ui The UI instance used to display the tasks.
+     */
+    public void showTasks(Ui ui) {
+        ui.showTaskList(tasks, taskCount);
+    }
+
+    /**
+     * Returns the number of tasks in the list.
+     *
+     * @return The number of tasks in the list.
+     */
+    public int getTaskCount() {
+        return taskCount;
+    }
+
+    /**
+     * Searches for tasks containing the specified keyword and displays the results.
+     *
+     * @param keyword The keyword to search for.
+     * @param ui      The UI instance used to display the search results.
+     */
+    public void findTasks(String keyword, Ui ui) {
+        Task[] matchingTasks = new Task[taskCount];
+        int matchCount = 0;
+
+        for (int i = 0; i < taskCount; i++) {
+            if (tasks[i].getTaskName().contains(keyword)) {
+                matchingTasks[matchCount++] = tasks[i];
+            }
+        }
+        if (matchCount > 0) {
+            ui.showSearchResults(matchingTasks, matchCount, keyword);
+        } else {
+            ui.showError("No tasks matched your search for: " + keyword);
+        }
+    }
+}
diff --git a/src/main/java/Todo.java b/src/main/java/Todo.java
new file mode 100644
index 000000000..56f782a92
--- /dev/null
+++ b/src/main/java/Todo.java
@@ -0,0 +1,36 @@
+/**
+ * Represents a Todo task, a specific type of Task with no additional time constraints.
+ * A Todo task includes a task name and its completion status.
+ */
+public class Todo extends Task {
+
+    /**
+     * Constructs a Todo task with the specified task name.
+     *
+     * @param taskName The name of the task.
+     */
+    public Todo(String taskName) {
+        super(taskName);
+    }
+
+    /**
+     * Returns a string representation of the Todo task, including its type indicator.
+     *
+     * @return A formatted string in the form of "[T][ ] taskName" or "[T][X] taskName".
+     */
+    @Override
+    public String toString() {
+        return "[T]" + super.toString();
+    }
+
+    /**
+     * Converts the Todo task into a formatted string for saving to a file.
+     *
+     * @return A string in the format "T | 1 | taskName" or "T | 0 | taskName",
+     *         where 1 indicates the task is completed, and 0 indicates it is not.
+     */
+    @Override
+    public String toFileFormat() {
+        return "T | " + (isDone ? "1" : "0") + " | " + taskName;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/Ui.java b/src/main/java/Ui.java
new file mode 100644
index 000000000..179d328e3
--- /dev/null
+++ b/src/main/java/Ui.java
@@ -0,0 +1,106 @@
+/**
+ * Represents the user interface for displaying messages and information to the user.
+ * This class contains static methods to interact with the user, including showing
+ * messages, task lists, and search results.
+ */
+public class Ui {
+
+    /**
+     * Displays the welcome message to the user.
+     */
+    public static void showWelcomeMessage() {
+        System.out.println("Hello! I'm Growler \nWhat can I do for you? \n");
+    }
+
+    /**
+     * Displays the goodbye message to the user.
+     */
+    public static void showGoodbyeMessage() {
+        System.out.println("Bye. Hope to see you again!");
+    }
+
+    /**
+     * Displays a message indicating a task has been added to the task list.
+     *
+     * @param task      The task that was added.
+     * @param taskCount The total number of tasks in the list after the addition.
+     */
+    public static void showTaskAdded(Task task, int taskCount) {
+        System.out.println("Got it. I've added this task:\n  " + task);
+        System.out.println("Now you have " + taskCount + " tasks in the list.");
+    }
+
+    /**
+     * Displays a message indicating a task has been removed from the task list.
+     *
+     * @param task      The task that was removed.
+     * @param taskCount The total number of tasks in the list after the removal.
+     */
+    public static void showTaskDeleted(Task task, int taskCount) {
+        System.out.println("Noted. I've removed this task:\n  " + task);
+        System.out.println("Now you have " + taskCount + " tasks in the list.");
+    }
+
+    /**
+     * Displays a message indicating a task has been marked as done.
+     *
+     * @param task The task that was marked as done.
+     */
+    public static void showTaskMarked(Task task) {
+        System.out.println("Nice! I've marked this task as done:\n  " + task);
+    }
+
+    /**
+     * Displays a message indicating a task has been marked as not done.
+     *
+     * @param task The task that was marked as not done.
+     */
+    public static void showTaskUnmarked(Task task) {
+        System.out.println("OK, I've marked this task as not done yet:\n  " + task);
+    }
+
+    /**
+     * Displays the list of tasks in the user's task list.
+     *
+     * @param tasks     An array of tasks to display.
+     * @param taskCount The total number of tasks in the list.
+     */
+    public static void showTaskList(Task[] tasks, int taskCount) {
+        System.out.println("Here are the tasks in your list:");
+        for (int i = 0; i < taskCount; i++) {
+            System.out.println((i + 1) + "." + tasks[i]);
+        }
+    }
+
+    /**
+     * Displays an error message to the user.
+     *
+     * @param message The error message to display.
+     */
+    public static void showError(String message) {
+        System.out.println("Error: " + message);
+    }
+
+    /**
+     * Displays a general message to the user.
+     *
+     * @param message The message to display.
+     */
+    public static void showMessage(String message) {
+        System.out.println("Message: " + message);
+    }
+
+    /**
+     * Displays the results of a task search to the user.
+     *
+     * @param tasks     An array of tasks that match the search criteria.
+     * @param taskCount The total number of matching tasks.
+     * @param keyword   The keyword used for the search.
+     */
+    public void showSearchResults(Task[] tasks, int taskCount, String keyword) {
+        Ui.showMessage("Here are the matching tasks in your list:");
+        for (int i = 0; i < taskCount; i++) {
+            System.out.println((i + 1) + "." + tasks[i]);
+        }
+    }
+}
diff --git a/text-ui-test/runtest.bat b/text-ui-test/runtest.bat
index 087374464..e443b752c 100644
--- a/text-ui-test/runtest.bat
+++ b/text-ui-test/runtest.bat
@@ -15,7 +15,7 @@ IF ERRORLEVEL 1 (
 REM no error here, errorlevel == 0
 
 REM run the program, feed commands from input.txt file and redirect the output to the ACTUAL.TXT
-java -classpath ..\bin Duke < input.txt > ACTUAL.TXT
+java -classpath ..\bin Growler < input.txt > ACTUAL.TXT
 
 REM compare the output to the expected output
 FC ACTUAL.TXT EXPECTED.TXT