diff --git a/docs/README.md b/docs/README.md
index 8077118eb..b8e70f33e 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -2,28 +2,174 @@
 
 ## Features 
 
-### Feature-ABC
+### Feature - Adding of Task - Todo, Event, Deadline 
 
-Description of the feature.
+You can now add a task of any one of the three types. 
 
-### Feature-XYZ
 
-Description of the feature.
+### Feature - Deletion of Task
+
+Delete any task according to its index in the list of tasks. 
+
+### Feature - Unmark/mark any task. 
+
+Mark or unmark any task in the list of task. 
+
+### Feature - List all tasks. 
+
+List all the current tasks in the list. 
+
+### Feature - Find a task, given a specific search word. 
+
+Enter a word and search for all tasks that contain this word. 
 
 ## Usage
 
-### `Keyword` - Describe action
+### `todo` - Describe action
+
+Describe the action and its outcome.
+
+Example of usage: 
+
+`todo enter description here`
+
+Expected outcome:
+
+Description of the outcome.
+
+```
+Got it. I've added this task:
+[T][ ]enter description here
+Now you have 1 tasks in the list.
+```
+
+### `deadline` - Describe action
 
 Describe the action and its outcome.
 
 Example of usage: 
 
-`keyword (optional arguments)`
+`deadline ip assignment /by today 2359`
 
 Expected outcome:
 
 Description of the outcome.
 
 ```
-expected output
+Got it. I've added this task:
+[D][ ]ip assignment (by today 2359)
+Now you have 1 tasks in the list.
 ```
+
+### `event` - Describe action
+
+Describe the action and its outcome.
+
+Example of usage: 
+
+`event final exam /at 29 February 9pm`
+
+Expected outcome:
+
+Description of the outcome.
+
+```
+Got it. I've added this task:
+[E][ ]final exam (at 29 February 9pm)
+Now you have 3 tasks in the list.
+```
+
+
+### `find` - Describe action
+
+Describe the action and its outcome.
+
+Example of usage: 
+
+`find final`
+
+Expected outcome:
+
+Description of the outcome.
+
+```
+Here are the matching tasks in your list: 
+3.[E][ ]final exam (at 29 February 9pm)
+```
+
+### `mark` - Describe action
+
+Describe the action and its outcome.
+
+Example of usage: 
+
+`mark 3`
+
+Expected outcome:
+
+Description of the outcome.
+
+```
+[T][ ]enter description here
+[D][ ]ip assignment (by today 2359)
+[E][X]final exam (at 29 February 9pm)
+```
+
+### `unmark` - Describe action
+
+Describe the action and its outcome.
+
+Example of usage: 
+
+`unmark 3`
+
+Expected outcome:
+
+Description of the outcome.
+
+```
+[T][ ]enter description here
+[D][ ]ip assignment (by today 2359)
+[E][ ]final exam (at 29 February 9pm)
+```
+
+### `list` - Describe action
+
+Describe the action and its outcome.
+
+Example of usage: 
+
+`list`
+
+Expected outcome:
+
+Description of the outcome.
+
+```
+Here are the tasks in your list : 
+1.[T][ ]enter description here
+2.[D][ ]ip assignment (by today 2359)
+3.[E][ ]final exam (at 29 February 9pm)
+```
+
+### `delete` - Describe action
+
+Describe the action and its outcome.
+
+Example of usage: 
+
+`delete 2`
+
+Expected outcome:
+
+Description of the outcome.
+
+```
+Noted. I've removed this task:
+[D][ ]ip assignment (by today 2359)
+Now you have 2 tasks in the list.
+[T][ ]enter description here
+[E][ ]final exam (at 29 February 9pm)
+
+```
+
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/META-INF/MANIFEST.MF b/src/main/java/META-INF/MANIFEST.MF
new file mode 100644
index 000000000..6e864153e
--- /dev/null
+++ b/src/main/java/META-INF/MANIFEST.MF
@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: duke.Duke
+
diff --git a/src/main/java/duke/Duke.class b/src/main/java/duke/Duke.class
new file mode 100644
index 000000000..96c9150b3
Binary files /dev/null and b/src/main/java/duke/Duke.class differ
diff --git a/src/main/java/duke/Duke.java b/src/main/java/duke/Duke.java
new file mode 100644
index 000000000..7850cd6a5
--- /dev/null
+++ b/src/main/java/duke/Duke.java
@@ -0,0 +1,42 @@
+package duke;
+import duke.tasklist.*;
+
+public class Duke {
+
+    private Storage storage;
+    private TaskList tasks;
+    private Ui ui;
+
+    public Duke(String filePath) {
+        ui = new Ui();
+        storage = new Storage(filePath);
+        try {
+            tasks = new TaskList(storage.loadTaskList());
+        } catch (DukeException e) {
+            ui.showLoadingError("Error in loading text file of tasks!");
+            tasks = new TaskList();
+        }
+    }
+    public void run() {
+        ui.showWelcome();
+        boolean endProgram = false;
+
+        while (!endProgram) {
+            try {
+                String command = ui.readCommand();
+                int continueProgram = Parser.parse(command,tasks,storage);
+                if (continueProgram == 0) {
+                    endProgram = true;
+                }
+            } catch (DukeException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        new Duke("tasks.txt").run();
+    }
+
+}
+
diff --git a/src/main/java/duke/DukeException.class b/src/main/java/duke/DukeException.class
new file mode 100644
index 000000000..cb02d3346
Binary files /dev/null and b/src/main/java/duke/DukeException.class differ
diff --git a/src/main/java/duke/DukeException.java b/src/main/java/duke/DukeException.java
new file mode 100644
index 000000000..6ed6f9d70
--- /dev/null
+++ b/src/main/java/duke/DukeException.java
@@ -0,0 +1,9 @@
+package duke;
+public class DukeException extends Exception{
+
+
+    public DukeException(String message) {
+        super(message);
+    }
+
+}
diff --git a/src/main/java/duke/File.class b/src/main/java/duke/File.class
new file mode 100644
index 000000000..55dc58c0f
--- /dev/null
+++ b/src/main/java/duke/File.class
@@ -0,0 +1,4 @@
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
diff --git a/src/main/java/duke/Parser.java b/src/main/java/duke/Parser.java
new file mode 100644
index 000000000..06eabcf30
--- /dev/null
+++ b/src/main/java/duke/Parser.java
@@ -0,0 +1,142 @@
+package duke;
+import duke.Storage;
+import duke.tasklist.*;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+/**
+ * Parser helps to make sense of the user input and uses methods from TaskList to do operations on the ArrayList of tasks.
+ */
+public class Parser {
+    public static int parse(String userInput, TaskList l,Storage s) throws DukeException {
+        String desc;
+        int index;
+        String by;
+        switch (userInput.split(" ")[0]) {
+            case "find":
+                String keyword = userInput.split(" ")[1];
+                l.find(keyword);
+                return 1;
+
+
+            case "todo":
+                desc = userInput.substring(5);
+                if (desc.isEmpty() || desc.isBlank()) {
+                    throw new DukeException("Oops! Description cannot be empty.");
+                }
+                desc = l.addTodo(desc);
+                try {
+                    if (l.getTaskSize() == 1) {
+                        s.writeToFile(desc);
+                    }
+                     else {
+                         s.appendData(desc);
+                     }
+                } catch (IOException e) {
+                    System.out.println("Error while appending to text file.");
+                }
+
+                return 1;
+
+
+            case "event":
+                index = userInput.indexOf("/");
+                desc = userInput.substring(6,index);
+                if (desc.isEmpty() || desc.isBlank()) {
+                    throw new DukeException("Oops! Description cannot be empty.");
+                }
+                index++;
+                by = userInput.substring(index);
+                if (by.isEmpty() || by.isBlank()) {
+                    throw new DukeException("Oops! You need a date for event.");
+                }
+                desc = l.addEvent(desc,by);
+                try {
+                    if (l.getTaskSize() == 1) {
+                        s.writeToFile(desc);
+                    }
+                    else {
+                        s.appendData(desc);
+                    }
+
+                } catch (IOException e) {
+                    System.out.println("Error while appending to text file.");
+                }
+                return 1;
+
+
+            case "deadline":
+                index = userInput.indexOf("/");
+                desc = userInput.substring(9,index);
+                if (desc.isEmpty() || desc.isBlank()) {
+                    throw new DukeException("Oops! Description cannot be empty.");
+                }
+                index++;
+                by = userInput.substring(index);
+                if (by.isEmpty() || by.isBlank()) {
+                    throw new DukeException("Oops! You need a date for deadline.");
+                }
+                desc = l.addDeadline(desc,by);
+                try {
+                    if (l.getTaskSize() == 1) {
+                        s.writeToFile(desc);
+                    }
+                    else {
+                        s.appendData(desc);
+                    }
+                } catch (IOException e) {
+                    System.out.println("Error while appending to text file.");
+                }
+                return 1;
+
+
+
+            case "mark":
+                String[] arrOfStr = userInput.split(" ", 0);
+                String indexValue = arrOfStr[1];
+                int indexValue2 = Integer.parseInt(indexValue) - 1;
+                //index given is out of array size
+                if (indexValue2 > l.getTaskSize()-1 || indexValue2 < 0){
+                    throw new DukeException("Index given is out of bounds.");
+                }
+                ArrayList<Task> taskList = l.markTask(indexValue2);
+                s.updateFile(taskList);
+                return 1;
+
+            case "unmark":
+                arrOfStr = userInput.split(" ", 0);
+                indexValue = arrOfStr[1];
+                indexValue2 = Integer.parseInt(indexValue) - 1;
+                //index given is out of array size
+                if (indexValue2 > l.getTaskSize()-1 || indexValue2 < 0){
+                    throw new DukeException("Index given is out of bounds.");
+                }
+                taskList = l.unmarkTask(indexValue2);
+                s.updateFile(taskList);
+                return 1;
+
+            case "delete":
+                arrOfStr = userInput.split(" ", 0);
+                indexValue = arrOfStr[1];
+                indexValue2 = Integer.parseInt(indexValue) - 1;
+                //index given is out of array size
+                if (indexValue2 > l.getTaskSize()-1 || indexValue2 < 0){
+                    throw new DukeException("Index given is out of bounds.");
+                }
+                taskList = l.deleteTask(indexValue2);
+                s.updateFile(taskList);
+                return 1;
+
+            case "list":
+                l.printList();
+                return 1;
+
+            case "bye":
+                return 0;
+
+            default:
+                throw new DukeException("Oops! I do not recognize this command. Please try again.");
+        }
+    }
+}
diff --git a/src/main/java/duke/Storage.java b/src/main/java/duke/Storage.java
new file mode 100644
index 000000000..0e9ef5e17
--- /dev/null
+++ b/src/main/java/duke/Storage.java
@@ -0,0 +1,181 @@
+package duke;
+
+import duke.tasklist.Task;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+import duke.tasklist.*;
+
+/**
+ * Storage class is used to load tasks from the file and saving them to taskList<ArrayList>
+ * We also have different functions which we will use in our commands to update the text file as we update the taskList.
+ */
+public class Storage {
+    private String filePath;
+    private File file;
+    private Scanner input;
+
+
+    /**
+     * reads in the link to our text file and saves it to variable input
+     * if text file does not exist, we create a new file
+     * @param filePath
+     */
+    public Storage(String filePath) {
+        try {
+            this.filePath = filePath;
+            this.file = new File(filePath);
+            if (this.file.createNewFile()) {
+                System.out.println("File is created!");
+            }else{
+                System.out.println("File exists, reading it to taskList!"); }
+            input = new Scanner(file);
+        } catch (FileNotFoundException e) {
+            createFileAndDirectory();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public String getFilePath() {
+        return this.filePath;
+    }
+
+
+    public void createFileAndDirectory() {
+        try {
+            file.createNewFile();
+            throw new IOException();
+        } catch (IOException e) {
+            System.out.println("Error creating file.");
+        }
+    }
+
+    /**
+     * function reads in our text file and saves it to an ArrayList of tasks.
+     *
+     * @return
+     * @throws DukeException
+     */
+    public ArrayList<Task> loadTaskList() throws DukeException {
+        ArrayList<Task> taskList = new ArrayList<>();
+        if (!file.exists() || !file.isFile()) {
+            return taskList;
+        }
+
+        while (input.hasNext()){
+            String nextString = input.nextLine();
+            String[] splitString = nextString.split("\\|");
+            String typeTask = splitString[0].replaceAll(" ","");
+            String marked = splitString[1].replaceAll(" ","");
+            String desc = splitString[2];
+            System.out.println(typeTask);
+            System.out.println(marked);
+            System.out.println(desc);
+            String todo = "T";
+            String deadline = "D";
+            String event = "E";
+            String toMark = "1";
+            if (typeTask.equals(todo)) {
+                taskList.add(new Todo(desc));
+                if (marked.equals(toMark)) {
+                    taskList.get(taskList.size()-1).markTask();
+                }
+            }
+
+            else if (typeTask.equals(deadline)) {
+                String deadlineDate = splitString[3];
+                taskList.add(new Deadline(desc,deadlineDate));
+                if (marked.equals(toMark)) {
+                    taskList.get(taskList.size()-1).markTask();
+                }
+            }
+
+            else if (typeTask.equals(event)) {
+                String eventDate = splitString[3];
+                taskList.add(new Event(desc,eventDate));
+                if (marked.equals(toMark)) {
+                    taskList.get(taskList.size()-1).markTask();
+                }
+            }
+        }
+        input.close();
+        return taskList;
+    }
+
+    /**
+     * Function to append one line of data to our text file
+     * For adding of tasks
+     * @param textToAppend
+     * @throws IOException
+     */
+    public void appendData(String textToAppend) throws IOException {
+        String filePath = this.filePath;
+        FileWriter fw = new FileWriter(filePath,true);
+        fw.write(System.getProperty( "line.separator" ));
+        fw.write(textToAppend);
+        fw.close();
+    }
+
+    /**
+     * Function to write the first line to a text file.
+     * @param textToAdd
+     * @throws IOException
+     */
+
+    public void writeToFile(String textToAdd) throws IOException {
+        filePath = this.filePath;
+        FileWriter fw = new FileWriter(filePath);
+        fw.write(textToAdd);
+        fw.close();
+    }
+
+    /**
+     * Function to completely erase text file and update it according to our ArrayList.
+     * Used when we delete tasks, mark/unmark tasks
+     * @param taskList
+     */
+    public  void updateFile(ArrayList<Task> taskList) {
+        for (int i = 0; i<taskList.size(); i++) {
+            System.out.println(taskList.get(i).toString());
+            String taskListLine = taskList.get(i).toString();
+            String marked = "0";
+            String textToAdd = "";
+            if ( taskListLine.charAt(4)==('X') ) {
+                marked = "1";
+            }
+
+            String typeTask = Character.toString(taskListLine.charAt(1));
+            if (typeTask.equals("T")) {
+                textToAdd = typeTask + "|" + marked + "|" + taskListLine.substring(6);
+            }
+
+            else {
+                int index = taskListLine.indexOf("(");
+                int index2 = taskListLine.indexOf(")");
+                textToAdd = typeTask + "|" + marked + "|" + taskListLine.substring(6,index) + "|" + taskListLine.substring(index+1,index2);
+            }
+
+            if (i==0){
+                try {
+                    writeToFile(textToAdd);
+                } catch (IOException e) {
+                    System.out.println("Failed to update first line.");
+                }
+            }
+
+            else {
+                try {
+                    appendData(textToAdd);
+                } catch (IOException e) {
+                    System.out.println("Failed to append line.");
+                }
+            }
+
+        }
+    }
+}
diff --git a/src/main/java/duke/Ui.java b/src/main/java/duke/Ui.java
new file mode 100644
index 000000000..39df498e7
--- /dev/null
+++ b/src/main/java/duke/Ui.java
@@ -0,0 +1,68 @@
+package duke;
+import java.util.Scanner;
+import java.io.InputStream;
+
+/**
+ * @author TaiAnn
+ */
+
+
+public class Ui {
+    private static final String LINESEPERATOR = "_________________________________________________\n";
+    private final Scanner input;
+    private String output;
+
+    public Ui() {
+        this(System.in);
+    }
+
+
+    public Ui(InputStream input) {
+        this.input = new Scanner(input);
+    }
+
+    private static boolean ignoreSpace(String rawInputLine) {
+        return rawInputLine.trim().isEmpty();
+    }
+
+    /**
+     * Handles the main UI of the application
+     */
+    public static void showWelcome() {
+
+        System.out.println(LINESEPERATOR +
+                "\tHello! I'm Duke.\n"  +
+                "\tWhat can I do for you?\n" +
+                "\tHere are the list of menu: \n" +
+                "\t 1. todo ... \n" +
+                "\t 2. deadline ... by ... \n" +
+                "\t 3. event ... at ... \n" +
+                "\t 4. list = show the entire list of tasks! \n" +
+                "\t 5. mark ...(number) \n" +
+                "\t 6. unmark ...(number) \n" +
+                "\t 7. delete ...(number) \n" +
+                "\t 8. find ... \n" +
+
+                LINESEPERATOR);
+    }
+
+    public void showGoodbyeMessage() {
+        output = LINESEPERATOR + "Bye. Hope to see you again soon.\n" + LINESEPERATOR;
+    }
+
+
+    /**
+     * Reads in a user input and returns it
+     * @return
+     */
+    public String readCommand() {
+        System.out.println("Please choose a command: " );
+        String user_input = input.nextLine();
+        return user_input;
+    }
+
+    public String showLoadingError(String errorMessage) {
+        return LINESEPERATOR + ":( OOPS!!! " + errorMessage + "\n" + LINESEPERATOR;
+    }
+}
+
diff --git a/src/main/java/duke/tasklist/Deadline.class b/src/main/java/duke/tasklist/Deadline.class
new file mode 100644
index 000000000..c8afc89a3
Binary files /dev/null and b/src/main/java/duke/tasklist/Deadline.class differ
diff --git a/src/main/java/duke/tasklist/Deadline.java b/src/main/java/duke/tasklist/Deadline.java
new file mode 100644
index 000000000..bb700197d
--- /dev/null
+++ b/src/main/java/duke/tasklist/Deadline.java
@@ -0,0 +1,18 @@
+package duke.tasklist;
+
+public class Deadline extends Task {
+
+    protected String by;
+
+    public Deadline(String description, String by) {
+        super(description);
+        this.by = by;
+    }
+
+    @Override
+    public String toString() {
+        // return "[D]" + super.toString() + "(" + by + ")";
+        return "[D]" + super.toString() + "(" + by + ")" ; // mark done task with X
+
+     }
+}
\ No newline at end of file
diff --git a/src/main/java/duke/tasklist/Event.class b/src/main/java/duke/tasklist/Event.class
new file mode 100644
index 000000000..33e375f77
Binary files /dev/null and b/src/main/java/duke/tasklist/Event.class differ
diff --git a/src/main/java/duke/tasklist/Event.java b/src/main/java/duke/tasklist/Event.java
new file mode 100644
index 000000000..485c44bbd
--- /dev/null
+++ b/src/main/java/duke/tasklist/Event.java
@@ -0,0 +1,16 @@
+package duke.tasklist;
+
+public class Event extends Task {
+
+    protected String timing;
+
+    public Event(String description, String timing) {
+        super(description);
+        this.timing = timing; 
+    }
+
+    @Override
+    public String toString() {
+        return "[E]" + super.toString() + "(" + timing + ")" ; // mark done task with X
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/duke/tasklist/Task.class b/src/main/java/duke/tasklist/Task.class
new file mode 100644
index 000000000..18ece3055
Binary files /dev/null and b/src/main/java/duke/tasklist/Task.class differ
diff --git a/src/main/java/duke/tasklist/Task.java b/src/main/java/duke/tasklist/Task.java
new file mode 100644
index 000000000..746eb1f90
--- /dev/null
+++ b/src/main/java/duke/tasklist/Task.java
@@ -0,0 +1,28 @@
+package duke.tasklist;
+public class Task {
+    protected String description;
+    protected boolean isDone;
+
+    public Task(String description) {
+        this.description = description;
+        this.isDone = false;
+    }
+
+    public String getDescription() {
+        return this.description;
+    }
+
+    public String toString() {
+        return (isDone ? "[X]"+ this.description : "[ ]"+ this.description); // mark done task with X
+    }
+
+    public void markTask() { 
+        this.isDone = true; 
+    }
+
+    public void unmarkTask() { 
+        this.isDone = false; 
+    }
+
+    
+}
\ No newline at end of file
diff --git a/src/main/java/duke/tasklist/TaskList.java b/src/main/java/duke/tasklist/TaskList.java
new file mode 100644
index 000000000..fe1458b4d
--- /dev/null
+++ b/src/main/java/duke/tasklist/TaskList.java
@@ -0,0 +1,97 @@
+package duke.tasklist;
+import java.util.ArrayList;
+import duke.DukeException;
+import java.io.IOException;
+
+import duke.Storage;
+
+
+public class TaskList {
+    private ArrayList<Task> taskList;
+
+
+    public TaskList(ArrayList<Task> a) {
+        this.taskList = a;
+    }
+
+    public TaskList() {
+        this.taskList = new ArrayList<Task>();
+    }
+
+    public int getTaskSize() {
+        return this.taskList.size();
+    }
+
+    public void printList() {
+        System.out.println("Here are the tasks in your list : ");
+        for (int i = 0; i<taskList.size(); i++) {
+            System.out.println(i+1 + "." + taskList.get(i).toString());
+        }
+    }
+
+    public ArrayList<Task> deleteTask(int indexValue2) {
+
+        Task removedTask = taskList.get(indexValue2);
+        taskList.remove(indexValue2);
+        System.out.println("Noted. I've removed this task:");
+        System.out.println(removedTask.toString());
+        System.out.println("Now you have " + taskList.size() + " tasks in the list.");
+        return this.taskList;
+    }
+
+    public String addTodo(String desc) {
+
+        System.out.println("Got it. I've added this task:");
+        taskList.add(new Todo(desc));
+        System.out.println(taskList.get(taskList.size()-1).toString());
+        System.out.println("Now you have " + taskList.size() + " tasks in the list.");
+        String textToAdd = "T" + "|" + " 0 " + "|" + desc;
+        // return this string so Storage can use to add to text file
+        return textToAdd;
+
+    }
+
+    public String addDeadline(String desc, String by) {
+        taskList.add(new Deadline(desc, by));
+        System.out.println("Got it. I've added this task:");
+        System.out.println(taskList.get(taskList.size() - 1).toString());
+        System.out.println("Now you have " + taskList.size() + " tasks in the list.");
+        String textToAdd = "D" + "|" + " 0 " + "|" + desc + "|" + by;
+        return textToAdd;
+
+    }
+
+    public String addEvent(String desc, String by)  {
+
+        taskList.add(new Event(desc,by));
+        System.out.println("Got it. I've added this task:");
+        System.out.println(taskList.get(taskList.size()-1).toString());
+        System.out.println("Now you have " + taskList.size() + " tasks in the list.");
+
+        String textToAdd = "E" + "|" + " 0 " + "|" + desc + "|" + by;
+        return textToAdd;
+    }
+
+    public ArrayList<Task> markTask(int indexValue2) {
+        taskList.get(indexValue2).markTask();
+        return(this.taskList);
+    }
+
+    public ArrayList<Task> unmarkTask(int indexValue2) {
+        taskList.get(indexValue2).unmarkTask();
+        return(this.taskList);
+    }
+
+    public void find(String keyword){
+        System.out.println("Here are the matching tasks in your list: ");
+        for (int i = 0; i<taskList.size(); i++) {
+            if (taskList.get(i).getDescription().toLowerCase().contains(keyword.toLowerCase())) {
+                System.out.println(i+1 + "." + taskList.get(i).toString());
+            }
+
+        }
+
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/main/java/duke/tasklist/Todo.class b/src/main/java/duke/tasklist/Todo.class
new file mode 100644
index 000000000..f54fa0f47
Binary files /dev/null and b/src/main/java/duke/tasklist/Todo.class differ
diff --git a/src/main/java/duke/tasklist/Todo.java b/src/main/java/duke/tasklist/Todo.java
new file mode 100644
index 000000000..202a555f4
--- /dev/null
+++ b/src/main/java/duke/tasklist/Todo.java
@@ -0,0 +1,13 @@
+package duke.tasklist;
+
+public class Todo extends Task{
+
+    public Todo(String description) {
+        super(description);
+    }
+
+    @Override
+    public String toString() {
+        return "[T]" + super.toString();
+    }
+}
\ No newline at end of file
diff --git a/tasks.txt b/tasks.txt
new file mode 100644
index 000000000..9d7ea0958
--- /dev/null
+++ b/tasks.txt
@@ -0,0 +1 @@
+T| 0 |adbc
\ No newline at end of file
diff --git a/text-ui-test/input.txt b/text-ui-test/input.txt
index e69de29bb..0a2ad522f 100644
--- a/text-ui-test/input.txt
+++ b/text-ui-test/input.txt
@@ -0,0 +1,5 @@
+todo borrow book 
+deadline return book /by Sunday
+event project meeting /at Mon 2-4pm
+
+	 
\ No newline at end of file