diff --git a/w6/questions.md b/w6/questions.md
new file mode 100644
index 0000000000000000000000000000000000000000..10cad129d245e2ec2ccddb12cb896535a7463569
--- /dev/null
+++ b/w6/questions.md
@@ -0,0 +1,55 @@
+1. Can you think of why we use `fork/execvp` instead of just calling `execvp` directly? What value do you think the `fork` provides?
+
+    > **Answer**:  _start here_
+    > We use `fork()` to create a new child process before calling `execvp()` so that the new process can replace its image with the desired executable. The value of `fork()` is that it allows the parent process (the shell) to remain running while the child process executes the command. This enables process control, such as waiting for the child to complete, handling multiple commands, and supporting job control features like background execution.
+
+
+2. What happens if the fork() system call fails? How does your implementation handle this scenario?
+
+    > **Answer**:  _start here_
+    > If `fork()` fails, it returns `-1`, indicating that no child process was created. This typically happens when system resources (like process table slots) are exhausted. My implementation handles this by checking the return value of `fork()` and printing an error message using `perror("fork failed")`. The function then returns `ERR_EXEC_CMD` to signal failure to the caller.
+
+
+3. How does execvp() find the command to execute? What system environment variable plays a role in this process?
+
+    > **Answer**:  _start here_
+    > `execvp()` searches for the command in the directories specified by the `PATH` environment variable. It checks each directory listed in `PATH` and attempts to execute the command from there. If the command is not found in any of the `PATH` directories, `execvp()` fails and sets `errno` accordingly.
+
+
+4. What is the purpose of calling wait() in the parent process after forking? What would happen if we didn’t call it?
+
+    > **Answer**:  _start here_
+    > The `wait()` system call allows the parent process to pause execution until the child process terminates. This prevents zombie processes (defunct processes that remain in the process table). If we didn’t call `wait()`, the child process would complete execution but still exist in the process table until the parent reaps it, leading to resource leaks.
+
+
+5. In the referenced demo code we used WEXITSTATUS(). What information does this provide, and why is it important?
+
+    > **Answer**:  _start here_
+    > `WEXITSTATUS(status)` extracts the exit status of a terminated child process from the status code returned by `waitpid()`. It provides the return code of the executed command, allowing the shell to determine if the command succeeded (exit status `0`) or failed (nonzero exit status). This is crucial for scripting and error handling.
+
+
+6. Describe how your implementation of build_cmd_buff() handles quoted arguments. Why is this necessary?
+
+    > **Answer**:  _start here_
+    > My `build_cmd_buff()` function correctly detects quoted arguments by toggling an `in_quotes` flag whenever it encounters a double quote (`"`). It ensures that spaces within quotes are treated as part of the argument rather than as separators. This is necessary because many shell commands require passing multi-word strings as single arguments (e.g., `echo "Hello World"` should be treated as one argument).
+
+
+7. What changes did you make to your parsing logic compared to the previous assignment? Were there any unexpected challenges in refactoring your old code?
+
+    > **Answer**:  _start here_
+    > In this assignment, I improved handling of argument splitting by properly managing spaces inside quotes. Additionally, I added checks for argument limits (`CMD_ARGV_MAX`) and included error handling for too many arguments. The main challenge was ensuring that special characters (like `"` and spaces) were handled correctly while maintaining robust error reporting.
+
+
+8. For this quesiton, you need to do some research on Linux signals. You can use [this google search](https://www.google.com/search?q=Linux+signals+overview+site%3Aman7.org+OR+site%3Alinux.die.net+OR+site%3Atldp.org&oq=Linux+signals+overview+site%3Aman7.org+OR+site%3Alinux.die.net+OR+site%3Atldp.org&gs_lcrp=EgZjaHJvbWUyBggAEEUYOdIBBzc2MGowajeoAgCwAgA&sourceid=chrome&ie=UTF-8) to get started.
+
+- What is the purpose of signals in a Linux system, and how do they differ from other forms of interprocess communication (IPC)?
+
+    > **Answer**:  _start here_
+
+- Find and describe three commonly used signals (e.g., SIGKILL, SIGTERM, SIGINT). What are their typical use cases?
+
+    > **Answer**:  _start here_
+
+- What happens when a process receives SIGSTOP? Can it be caught or ignored like SIGINT? Why or why not?
+
+    > **Answer**:  _start here_
\ No newline at end of file