diff --git a/scripts/interpreter/gen_commit.py b/scripts/interpreter/gen_commit.py
index ce964ac..8775ee7 100755
--- a/scripts/interpreter/gen_commit.py
+++ b/scripts/interpreter/gen_commit.py
@@ -4,34 +4,21 @@ import subprocess
 from dotenv import load_dotenv
 from interpreter import OpenInterpreter
 
-# Load environment variables from .env
-load_dotenv()
-
-# Constants
-COMMIT_CONVENTION_PATH = os.path.join(os.path.dirname(__file__), "resources/commit_convention.md")
-GIT_COMMANDS_PATH = os.path.join(os.path.dirname(__file__), "resources/git_commit.md")
+load_dotenv()  # Load environment variables from .env
 
 
-def parse_cli_args():
-    """
-    Parse and validate command-line arguments.
-    Returns:
-        tuple: (git_user, git_pass, git_repo, project_path)
-    """
+def get_git_credentials():
+    """Retrieve Git credentials and project path from command-line arguments."""
     if len(sys.argv) != 5:
-        sys.exit("Usage: python gen_commit.py <GIT_USER> <GIT_PASS> <GIT_REPO> <PROJECT_PATH>")
+        print(
+            "Usage: python gen_commit.py <GIT_USER> <GIT_PASS> <GIT_REPO> <PROJECT_PATH>"
+        )
+        sys.exit(1)
     return sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
 
 
-def run_shell_command(command, cwd=None):
-    """
-    Execute a shell command and return the output.
-    Args:
-        command (str): Command to run.
-        cwd (str): Optional working directory.
-    Returns:
-        str: Command output.
-    """
+def run_command(command, cwd=None):
+    """Run a shell command and return the output."""
     try:
         result = subprocess.run(
             command,
@@ -44,80 +31,83 @@ def run_shell_command(command, cwd=None):
         )
         return result.stdout.strip()
     except subprocess.CalledProcessError as e:
-        print(f"[ERROR] Command failed: {command}\n{e.stderr}")
+        print(f"Command failed: {command}\n{e.stderr}")
         return ""
 
 
-def read_file(path):
-    """Read the contents of a file."""
-    with open(path, "r", encoding="utf-8") as f:
-        return f.read()
+def gen_commit(project_path):
+    """Use OpenInterpreter to generate a commit message based on git diff."""
 
-
-def generate_commit_message(project_path):
-    """
-    Use OpenInterpreter to generate a commit message based on the git diff.
-    Args:
-        project_path (str): Path to the project directory.
-    Returns:
-        str: Generated commit message.
-    """
     agent = OpenInterpreter()
     agent.llm.model = "gpt-4o"
     agent.auto_run = True
 
-    convention = read_file(COMMIT_CONVENTION_PATH)
-    git_commands = read_file(GIT_COMMANDS_PATH)
+    # Read both convention and git commit files
+    convention_path = os.path.join(
+        os.path.dirname(__file__), "resources/commit_convention.md"
+    )
+    git_commit_path = os.path.join(os.path.dirname(__file__), "resources/git_commit.md")
+
+    with open(convention_path, "r") as f:
+        convention_content = f.read()
+    with open(git_commit_path, "r") as f:
+        git_commit_content = f.read()
 
     agent.system_message = f"""
     Your name is Bifrost.
     You are a helpful assistant that generates commit messages based on uncommitted code.
 
-    Rules:
+    Follow these rules:
     1. Use English.
-    2. Follow this format:
-    {convention}
-
-    3. Use these git commands to analyze changes:
-    {git_commands}
-
-    4. Return only the commit message. No explanations or extra output.
+    2. Be concise and follow this format:
+    {convention_content}
+    
+    3. Use these git commands to analyze changes as you see fit:
+    {git_commit_content}
+    
+    4. Only return the commit message. Do not add explanation or extra output.
     """
 
     prompt = f"""
+    Generate a commit message based on the following changes in the project directory:
+
+    First, change directory:
     cd {project_path}
-    Check for uncommitted changes in the repository and generate a commit message accordingly.
+
+    Then check the uncommitted changes.
+
+    Then generate a commit message according to the changes.
     """
 
     response = agent.chat(prompt)
 
-    if isinstance(response, list):
-        for item in reversed(response):
-            if isinstance(item, dict) and "content" in item:
-                return item["content"].strip()
+    # Extract just the content from the response
+    if isinstance(response, list) and len(response) > 0:
+        if isinstance(response[-1], dict) and "content" in response[-1]:
+            return response[-1]["content"].strip()
 
     return str(response).strip()
 
 
-def commit_and_push_code():
-    """
-    Pull, generate commit message, commit changes, and push to remote repository.
-    """
-    git_user, git_pass, git_repo, project_path = parse_cli_args()
+def push_code():
+    """Pull, commit, and push code with AI-generated message."""
+    git_user, git_pass, git_repo, project_path = get_git_credentials()
 
+    # Change to project path
     os.chdir(project_path)
 
-    commit_msg = generate_commit_message(project_path)
-    print(f"Generated Commit Message:\n{commit_msg}\n")
+    # Generate commit message
+    commit_msg = gen_commit(project_path)
+    print(f"Generated commit message:\n{commit_msg}\n")
 
+    # Pull, add, commit, and push
     remote_url = f"https://{git_user}:{git_pass}@{git_repo}"
 
-    # Run Git commands
-    run_shell_command(f"git pull {remote_url} || true")
-    run_shell_command("git add .")
-    run_shell_command(f'git commit -m "{commit_msg}" || true')
-    run_shell_command(f"git push {remote_url} || true")
+    run_command(f"git pull {remote_url} || true")
+    run_command("git add .")
+    run_command(f'git commit -m "{commit_msg}" || true')
+    run_command(f"git push {remote_url} || true")
 
 
 if __name__ == "__main__":
-    commit_and_push_code()
+    push_code()