diff --git a/README.md b/README.md
index 2f50bb7..f2da257 100644
--- a/README.md
+++ b/README.md
@@ -21,6 +21,7 @@ Kernel provides sandboxed, ready-to-use Chrome browsers for browser automations
 
 ### What you can do with the CLI
 
+- Create new Kernel applications from templates
 - Deploy and version apps to Kernel
 - Invoke app actions (sync or async) and stream logs
 - Create, list, view, and delete managed browser sessions
@@ -50,19 +51,25 @@ kernel --version
 
 ## Quick Start
 
-1. **Authenticate with Kernel:**
+1. **Create a new Kernel app:**
+
+   ```bash
+   kernel create
+   ```
+
+2. **Authenticate with Kernel:**
 
    ```bash
    kernel login
    ```
 
-2. **Deploy your first app:**
+3. **Deploy your app:**
 
    ```bash
    kernel deploy index.ts
    ```
 
-3. **Invoke your app:**
+4. **Invoke your app:**
    ```bash
    kernel invoke my-app action-name --payload '{"key": "value"}'
    ```
@@ -103,6 +110,20 @@ Create an API key from the [Kernel dashboard](https://dashboard.onkernel.com).
 - `kernel logout` - Clear stored credentials
 - `kernel auth` - Check authentication status
 
+### App Creation
+
+- `--name <name>`, `-n` - Name of the application
+- `--language <language>`, `-l` - Sepecify app language: `typescript`, or `python`
+- `--template <template>`, `-t` - Template to use:
+  - `sample-app` - Basic template with Playwright integration
+  - `advanced-sample` - Sample apps using advanced Kernel configs
+  - `stagehand` - Template with Stagehand SDK (TypeScript only)
+  - `browser-use` - Template with Browser Use SDK (Python only)
+  - `computer-use` - Anthropic Computer Use prompt loop
+  - `cua` - OpenAI Computer Using Agent (CUA) sample
+  - `gemini-cua` - Google Gemini CUA sample (TypeScript only)
+  - `magnitude` - Magnitude framework sample (TypeScript only)
+
 ### App Deployment
 
 - `kernel deploy <file>` - Deploy an app to Kernel
@@ -356,6 +377,25 @@ Create an API key from the [Kernel dashboard](https://dashboard.onkernel.com).
 
 ## Examples
 
+### Create a new app
+
+```bash
+# Interactive mode (prompts for all options)
+kernel create
+
+# Create a TypeScript app with sample template
+kernel create --name my-app --language typescript --template sample-app
+
+# Create a Python app with Browser Use
+kernel create --name my-scraper --language python --template browser-use
+
+# Create a TypeScript app with Stagehand
+kernel create --name my-agent --language ts --template stagehand
+
+# Create a Python Computer Use app
+kernel create --name my-cu-app --language py --template computer-use
+```
+
 ### Deploy with environment variables
 
 ```bash
diff --git a/cmd/create.go b/cmd/create.go
index 31d22ed..5427bd6 100644
--- a/cmd/create.go
+++ b/cmd/create.go
@@ -11,26 +11,32 @@ import (
 	"github.com/spf13/cobra"
 )
 
-type CreateInput struct {
-	Name     string
-	Language string
-	Template string
-}
-
 // CreateCmd is a cobra-independent command handler for create operations
 type CreateCmd struct{}
 
 // Create executes the creating a new Kernel app logic
-func (c CreateCmd) Create(ctx context.Context, ci CreateInput) error {
+func (c CreateCmd) Create(ctx context.Context, ci create.CreateInput) error {
 	appPath, err := filepath.Abs(ci.Name)
 	if err != nil {
 		return fmt.Errorf("failed to resolve app path: %w", err)
 	}
 
-	// TODO: handle overwrite gracefully (prompt user)
-	// Check if directory already exists
+	// Check if directory already exists and prompt for overwrite
 	if _, err := os.Stat(appPath); err == nil {
-		return fmt.Errorf("directory %s already exists", ci.Name)
+		overwrite, err := create.PromptForOverwrite(ci.Name)
+		if err != nil {
+			return fmt.Errorf("failed to prompt for overwrite: %w", err)
+		}
+
+		if !overwrite {
+			pterm.Warning.Println("Operation cancelled.")
+			return nil
+		}
+
+		// Remove existing directory
+		if err := os.RemoveAll(appPath); err != nil {
+			return fmt.Errorf("failed to remove existing directory: %w", err)
+		}
 	}
 
 	if err := os.MkdirAll(appPath, 0755); err != nil {
@@ -45,8 +51,9 @@ func (c CreateCmd) Create(ctx context.Context, ci CreateInput) error {
 		spinner.Fail("Failed to copy template files")
 		return fmt.Errorf("failed to copy template files: %w", err)
 	}
+	spinner.Success()
 
-	nextSteps, err := create.InstallDependencies(ci.Name, appPath, ci.Language)
+	nextSteps, err := create.InstallDependencies(appPath, ci)
 	if err != nil {
 		return fmt.Errorf("failed to install dependencies: %w", err)
 	}
@@ -91,7 +98,7 @@ func runCreateApp(cmd *cobra.Command, args []string) error {
 	}
 
 	c := CreateCmd{}
-	return c.Create(cmd.Context(), CreateInput{
+	return c.Create(cmd.Context(), create.CreateInput{
 		Name:     appName,
 		Language: language,
 		Template: template,
diff --git a/cmd/create_test.go b/cmd/create_test.go
index d04e201..614e758 100644
--- a/cmd/create_test.go
+++ b/cmd/create_test.go
@@ -14,17 +14,22 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const (
+	DIR_PERM  = 0755 // rwxr-xr-x
+	FILE_PERM = 0644 // rw-r--r--
+)
+
 func TestCreateCommand(t *testing.T) {
 	tests := []struct {
 		name        string
-		input       CreateInput
+		input       create.CreateInput
 		wantErr     bool
 		errContains string
 		validate    func(t *testing.T, appPath string)
 	}{
 		{
 			name: "create typescript sample-app",
-			input: CreateInput{
+			input: create.CreateInput{
 				Name:     "test-app",
 				Language: "typescript",
 				Template: "sample-app",
@@ -39,7 +44,7 @@ func TestCreateCommand(t *testing.T) {
 		},
 		{
 			name: "fail with invalid template",
-			input: CreateInput{
+			input: create.CreateInput{
 				Name:     "test-app",
 				Language: "typescript",
 				Template: "nonexistent",
@@ -112,7 +117,7 @@ func TestAllTemplatesWithDependencies(t *testing.T) {
 
 			// Create the app
 			c := CreateCmd{}
-			err = c.Create(context.Background(), CreateInput{
+			err = c.Create(context.Background(), create.CreateInput{
 				Name:     appName,
 				Language: tt.language,
 				Template: tt.template,
@@ -145,7 +150,7 @@ func TestAllTemplatesCreation(t *testing.T) {
 			appPath := filepath.Join(tmpDir, appName)
 
 			// Create app directory
-			err := os.MkdirAll(appPath, 0755)
+			err := os.MkdirAll(appPath, DIR_PERM)
 			require.NoError(t, err, "failed to create app directory")
 
 			// Copy template files without installing dependencies
@@ -258,7 +263,7 @@ func TestCreateCommand_DependencyInstallationFails(t *testing.T) {
 
 	// Create the app - should succeed even though dependency installation fails
 	c := CreateCmd{}
-	err = c.Create(context.Background(), CreateInput{
+	err = c.Create(context.Background(), create.CreateInput{
 		Name:     appName,
 		Language: create.LanguageTypeScript,
 		Template: "sample-app",
@@ -318,7 +323,7 @@ func TestCreateCommand_RequiredToolMissing(t *testing.T) {
 
 			// Create the app - should succeed even though required tool is missing
 			c := CreateCmd{}
-			err = c.Create(context.Background(), CreateInput{
+			err = c.Create(context.Background(), create.CreateInput{
 				Name:     appName,
 				Language: tt.language,
 				Template: tt.template,
@@ -352,6 +357,273 @@ func TestCreateCommand_RequiredToolMissing(t *testing.T) {
 	}
 }
 
+// TestCreateCommand_DirectoryOverwrite tests that overwriting an existing directory
+// properly removes old content and creates new content
+func TestCreateCommand_DirectoryOverwrite(t *testing.T) {
+	tmpDir := t.TempDir()
+	appName := "test-app"
+	appPath := filepath.Join(tmpDir, appName)
+
+	orgDir, err := os.Getwd()
+	require.NoError(t, err)
+
+	err = os.Chdir(tmpDir)
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		os.Chdir(orgDir)
+	})
+
+	// Initialize directory with some files
+	err = os.MkdirAll(appPath, DIR_PERM)
+	require.NoError(t, err, "failed to create initial directory")
+
+	// Create some initial files that should be removed after overwrite
+	oldFile1 := filepath.Join(appPath, "old-file-1.txt")
+	oldSubDir := filepath.Join(appPath, "old-subdir")
+
+	err = os.WriteFile(oldFile1, []byte("old content 1"), FILE_PERM)
+	require.NoError(t, err, "failed to create old file 1")
+
+	err = os.MkdirAll(oldSubDir, DIR_PERM)
+	require.NoError(t, err, "failed to create old subdirectory")
+
+	// Verify initial files exist
+	assert.FileExists(t, oldFile1, "old file 1 should exist before overwrite")
+	assert.DirExists(t, oldSubDir, "old subdirectory should exist before overwrite")
+
+	// Manually remove the directory and create the new app
+	err = os.RemoveAll(appPath)
+	require.NoError(t, err, "failed to remove existing directory")
+
+	c := CreateCmd{}
+	err = c.Create(context.Background(), create.CreateInput{
+		Name:     appName,
+		Language: create.LanguageTypeScript,
+		Template: "sample-app",
+	})
+	require.NoError(t, err, "failed to create new app")
+
+	// Verify old files are gone
+	assert.NoFileExists(t, oldFile1, "old file 1 should not exist after overwrite")
+	assert.NoDirExists(t, oldSubDir, "old subdirectory should not exist after overwrite")
+
+	// Verify new template files exist
+	assert.FileExists(t, filepath.Join(appPath, "index.ts"), "new index.ts should exist")
+}
+
+// TestCreateCommand_InvalidLanguageTemplateCombinations tests that invalid
+// language/template combinations fail with appropriate error messages
+func TestCreateCommand_InvalidLanguageTemplateCombinations(t *testing.T) {
+	tests := []struct {
+		name        string
+		language    string
+		template    string
+		errContains string
+	}{
+		{
+			name:        "browser-use not available for typescript",
+			language:    create.LanguageTypeScript,
+			template:    create.TemplateBrowserUse,
+			errContains: "template not found: typescript/browser-use",
+		},
+		{
+			name:        "stagehand not available for python",
+			language:    create.LanguagePython,
+			template:    create.TemplateStagehand,
+			errContains: "template not found: python/stagehand",
+		},
+		{
+			name:        "magnitude not available for python",
+			language:    create.LanguagePython,
+			template:    create.TemplateMagnitude,
+			errContains: "template not found: python/magnitude",
+		},
+		{
+			name:        "gemini-cua not available for python",
+			language:    create.LanguagePython,
+			template:    create.TemplateGeminiCUA,
+			errContains: "template not found: python/gemini-cua",
+		},
+		{
+			name:        "invalid language",
+			language:    "ruby",
+			template:    create.TemplateSampleApp,
+			errContains: "template not found: ruby/sample-app",
+		},
+		{
+			name:        "invalid template",
+			language:    create.LanguageTypeScript,
+			template:    "nonexistent-template",
+			errContains: "template not found: typescript/nonexistent-template",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpDir := t.TempDir()
+
+			orgDir, err := os.Getwd()
+			require.NoError(t, err)
+
+			err = os.Chdir(tmpDir)
+			require.NoError(t, err)
+
+			t.Cleanup(func() {
+				os.Chdir(orgDir)
+			})
+
+			c := CreateCmd{}
+			err = c.Create(context.Background(), create.CreateInput{
+				Name:     "test-app",
+				Language: tt.language,
+				Template: tt.template,
+			})
+
+			require.Error(t, err, "should fail with invalid language/template combination")
+			assert.Contains(t, err.Error(), tt.errContains, "error message should contain expected text")
+		})
+	}
+}
+
+// TestCreateCommand_ValidateAllTemplateCombinations validates that only valid
+// language/template combinations are defined in the Templates map
+func TestCreateCommand_ValidateAllTemplateCombinations(t *testing.T) {
+	// This test ensures data consistency between Templates and actual template availability
+	for templateKey, templateInfo := range create.Templates {
+		for _, lang := range templateInfo.Languages {
+			t.Run(lang+"/"+templateKey, func(t *testing.T) {
+				tmpDir := t.TempDir()
+				appPath := filepath.Join(tmpDir, "test-app")
+
+				err := os.MkdirAll(appPath, DIR_PERM)
+				require.NoError(t, err)
+
+				// This should succeed for all combinations defined in Templates
+				err = create.CopyTemplateFiles(appPath, lang, templateKey)
+				require.NoError(t, err, "Template %s should be available for language %s as defined in Templates map", templateKey, lang)
+			})
+		}
+	}
+}
+
+// TestCreateCommand_InvalidLanguageShorthand tests that invalid language shorthands
+// are handled appropriately
+func TestCreateCommand_InvalidLanguageShorthand(t *testing.T) {
+	tests := []struct {
+		name               string
+		languageInput      string
+		expectedNormalized string
+	}{
+		{
+			name:               "ts shorthand normalizes to typescript",
+			languageInput:      "ts",
+			expectedNormalized: create.LanguageTypeScript,
+		},
+		{
+			name:               "py shorthand normalizes to python",
+			languageInput:      "py",
+			expectedNormalized: create.LanguagePython,
+		},
+		{
+			name:               "typescript remains typescript",
+			languageInput:      "typescript",
+			expectedNormalized: create.LanguageTypeScript,
+		},
+		{
+			name:               "python remains python",
+			languageInput:      "python",
+			expectedNormalized: create.LanguagePython,
+		},
+		{
+			name:               "invalid shorthand remains unchanged",
+			languageInput:      "js",
+			expectedNormalized: "js",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			normalized := create.NormalizeLanguage(tt.languageInput)
+			assert.Equal(t, tt.expectedNormalized, normalized)
+		})
+	}
+}
+
+// TestCreateCommand_TemplateNotAvailableForLanguage tests specific cases where
+// templates are not available for certain languages
+func TestCreateCommand_TemplateNotAvailableForLanguage(t *testing.T) {
+	// Map of templates to languages they should NOT be available for
+	unavailableCombinations := map[string][]string{
+		create.TemplateBrowserUse: {create.LanguageTypeScript},
+		create.TemplateStagehand:  {create.LanguagePython},
+		create.TemplateMagnitude:  {create.LanguagePython},
+		create.TemplateGeminiCUA:  {create.LanguagePython},
+	}
+
+	for template, unavailableLanguages := range unavailableCombinations {
+		for _, lang := range unavailableLanguages {
+			t.Run(template+"/"+lang, func(t *testing.T) {
+				// Verify the template info doesn't list this language
+				templateInfo, exists := create.Templates[template]
+				require.True(t, exists, "Template %s should exist in Templates map", template)
+
+				assert.NotContains(t, templateInfo.Languages, lang,
+					"Template %s should not list %s as a supported language", template, lang)
+
+				// Verify copying fails
+				tmpDir := t.TempDir()
+				appPath := filepath.Join(tmpDir, "test-app")
+				err := os.MkdirAll(appPath, DIR_PERM)
+				require.NoError(t, err)
+
+				err = create.CopyTemplateFiles(appPath, lang, template)
+				require.Error(t, err, "Should fail to copy %s template for %s", template, lang)
+			})
+		}
+	}
+}
+
+// TestCreateCommand_AllTemplatesHaveDeployCommands ensures that all templates
+// have corresponding deploy commands defined
+func TestCreateCommand_AllTemplatesHaveDeployCommands(t *testing.T) {
+	for templateKey, templateInfo := range create.Templates {
+		for _, lang := range templateInfo.Languages {
+			t.Run(lang+"/"+templateKey, func(t *testing.T) {
+				deployCmd := create.GetDeployCommand(lang, templateKey)
+				assert.NotEmpty(t, deployCmd, "Deploy command should exist for %s/%s", lang, templateKey)
+
+				// Verify deploy command starts with "kernel deploy"
+				assert.Contains(t, deployCmd, "kernel deploy", "Deploy command should start with 'kernel deploy'")
+
+				// Verify it contains the entry point
+				switch lang {
+				case create.LanguageTypeScript:
+					assert.Contains(t, deployCmd, "index.ts", "TypeScript deploy command should contain index.ts")
+				case create.LanguagePython:
+					assert.Contains(t, deployCmd, "main.py", "Python deploy command should contain main.py")
+				}
+			})
+		}
+	}
+}
+
+// TestCreateCommand_AllTemplatesHaveInvokeSamples ensures that all templates
+// have corresponding invoke samples defined
+func TestCreateCommand_AllTemplatesHaveInvokeSamples(t *testing.T) {
+	for templateKey, templateInfo := range create.Templates {
+		for _, lang := range templateInfo.Languages {
+			t.Run(lang+"/"+templateKey, func(t *testing.T) {
+				invokeCmd := create.GetInvokeSample(lang, templateKey)
+				assert.NotEmpty(t, invokeCmd, "Invoke sample should exist for %s/%s", lang, templateKey)
+
+				// Verify invoke command starts with "kernel invoke"
+				assert.Contains(t, invokeCmd, "kernel invoke", "Invoke command should start with 'kernel invoke'")
+			})
+		}
+	}
+}
+
 func getTemplateInfo() []struct {
 	name     string
 	language string
diff --git a/pkg/create/copy_test.go b/pkg/create/copy_test.go
new file mode 100644
index 0000000..c8228e5
--- /dev/null
+++ b/pkg/create/copy_test.go
@@ -0,0 +1,257 @@
+package create
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	testDirPerm  = 0755
+	testFilePerm = 0644
+)
+
+func TestCopyTemplateFiles_Success(t *testing.T) {
+	tests := []struct {
+		name     string
+		language string
+		template string
+		validate func(t *testing.T, appPath string)
+	}{
+		{
+			name:     "typescript sample-app",
+			language: LanguageTypeScript,
+			template: TemplateSampleApp,
+			validate: func(t *testing.T, appPath string) {
+				assert.FileExists(t, filepath.Join(appPath, "index.ts"))
+				assert.FileExists(t, filepath.Join(appPath, "package.json"))
+				assert.FileExists(t, filepath.Join(appPath, "tsconfig.json"))
+				assert.FileExists(t, filepath.Join(appPath, ".gitignore"))
+				assert.NoFileExists(t, filepath.Join(appPath, "_gitignore"))
+			},
+		},
+		{
+			name:     "python sample-app",
+			language: LanguagePython,
+			template: TemplateSampleApp,
+			validate: func(t *testing.T, appPath string) {
+				assert.FileExists(t, filepath.Join(appPath, "main.py"))
+				assert.FileExists(t, filepath.Join(appPath, "pyproject.toml"))
+				assert.FileExists(t, filepath.Join(appPath, ".gitignore"))
+				assert.NoFileExists(t, filepath.Join(appPath, "_gitignore"))
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpDir := t.TempDir()
+			appPath := filepath.Join(tmpDir, "test-app")
+
+			err := os.MkdirAll(appPath, testDirPerm)
+			require.NoError(t, err)
+
+			err = CopyTemplateFiles(appPath, tt.language, tt.template)
+			require.NoError(t, err, "CopyTemplateFiles should succeed")
+
+			if tt.validate != nil {
+				tt.validate(t, appPath)
+			}
+		})
+	}
+}
+
+func TestCopyTemplateFiles_InvalidTemplate(t *testing.T) {
+	tests := []struct {
+		name        string
+		language    string
+		template    string
+		errContains string
+	}{
+		{
+			name:        "nonexistent template",
+			language:    LanguageTypeScript,
+			template:    "nonexistent-template",
+			errContains: "template not found: typescript/nonexistent-template",
+		},
+		{
+			name:        "nonexistent language",
+			language:    "ruby",
+			template:    TemplateSampleApp,
+			errContains: "template not found: ruby/sample-app",
+		},
+		{
+			name:        "empty language",
+			language:    "",
+			template:    TemplateSampleApp,
+			errContains: "template not found",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpDir := t.TempDir()
+			appPath := filepath.Join(tmpDir, "test-app")
+
+			err := os.MkdirAll(appPath, testDirPerm)
+			require.NoError(t, err)
+
+			err = CopyTemplateFiles(appPath, tt.language, tt.template)
+			require.Error(t, err, "CopyTemplateFiles should fail with invalid template")
+			assert.Contains(t, err.Error(), tt.errContains)
+		})
+	}
+}
+
+func TestCopyTemplateFiles_GitignoreRename(t *testing.T) {
+	// Test that _gitignore is properly renamed to .gitignore
+	tmpDir := t.TempDir()
+	appPath := filepath.Join(tmpDir, "test-app")
+
+	err := os.MkdirAll(appPath, testDirPerm)
+	require.NoError(t, err)
+
+	err = CopyTemplateFiles(appPath, LanguageTypeScript, TemplateSampleApp)
+	require.NoError(t, err)
+
+	// Verify .gitignore exists
+	gitignorePath := filepath.Join(appPath, ".gitignore")
+	assert.FileExists(t, gitignorePath, ".gitignore should exist")
+
+	// Verify _gitignore does not exist
+	underscoreGitignorePath := filepath.Join(appPath, "_gitignore")
+	assert.NoFileExists(t, underscoreGitignorePath, "_gitignore should not exist")
+
+	// Verify .gitignore has content
+	content, err := os.ReadFile(gitignorePath)
+	require.NoError(t, err)
+	assert.NotEmpty(t, content, ".gitignore should have content")
+}
+
+func TestCopyTemplateFiles_FilePermissions(t *testing.T) {
+	tmpDir := t.TempDir()
+	appPath := filepath.Join(tmpDir, "test-app")
+
+	err := os.MkdirAll(appPath, testDirPerm)
+	require.NoError(t, err)
+
+	err = CopyTemplateFiles(appPath, LanguageTypeScript, TemplateSampleApp)
+	require.NoError(t, err)
+
+	// Check file permissions
+	indexPath := filepath.Join(appPath, "index.ts")
+	info, err := os.Stat(indexPath)
+	require.NoError(t, err)
+
+	// Verify file has correct permissions (0644)
+	mode := info.Mode()
+	assert.Equal(t, os.FileMode(FILE_PERM), mode.Perm(), "File should have 0644 permissions")
+}
+
+func TestCopyTemplateFiles_DirectoryPermissions(t *testing.T) {
+	tmpDir := t.TempDir()
+	appPath := filepath.Join(tmpDir, "test-app")
+
+	err := os.MkdirAll(appPath, testDirPerm)
+	require.NoError(t, err)
+
+	err = CopyTemplateFiles(appPath, LanguageTypeScript, TemplateSampleApp)
+	require.NoError(t, err)
+
+	// Check directory permissions
+	info, err := os.Stat(appPath)
+	require.NoError(t, err)
+
+	// Verify directory has correct permissions (0755)
+	mode := info.Mode()
+	assert.True(t, mode.IsDir(), "Should be a directory")
+	assert.Equal(t, os.FileMode(DIR_PERM), mode.Perm(), "Directory should have 0755 permissions")
+}
+
+func TestCopyTemplateFiles_PreservesDirectoryStructure(t *testing.T) {
+	tmpDir := t.TempDir()
+	appPath := filepath.Join(tmpDir, "test-app")
+
+	err := os.MkdirAll(appPath, testDirPerm)
+	require.NoError(t, err)
+
+	// Use a template that has subdirectories
+	err = CopyTemplateFiles(appPath, LanguageTypeScript, TemplateComputerUse)
+	require.NoError(t, err)
+
+	// Verify that subdirectories are created (computer-use has src/ directory)
+	srcDir := filepath.Join(appPath, "src")
+	if _, err := os.Stat(srcDir); err == nil {
+		assert.DirExists(t, srcDir, "Subdirectories should be preserved")
+	}
+}
+
+func TestCopyTemplateFiles_OverwritesExistingFiles(t *testing.T) {
+	tmpDir := t.TempDir()
+	appPath := filepath.Join(tmpDir, "test-app")
+
+	err := os.MkdirAll(appPath, testDirPerm)
+	require.NoError(t, err)
+
+	// Create an existing file with different content
+	existingFile := filepath.Join(appPath, "index.ts")
+	existingContent := []byte("// old content")
+	err = os.WriteFile(existingFile, existingContent, testFilePerm)
+	require.NoError(t, err)
+
+	// Copy template files (should overwrite)
+	err = CopyTemplateFiles(appPath, LanguageTypeScript, TemplateSampleApp)
+	require.NoError(t, err)
+
+	// Verify file was overwritten
+	newContent, err := os.ReadFile(existingFile)
+	require.NoError(t, err)
+	assert.NotEqual(t, existingContent, newContent, "File should be overwritten with new content")
+}
+
+func TestCopyTemplateFiles_InvalidDestinationPath(t *testing.T) {
+	// Test with a path that cannot be created (e.g., file exists where directory should be)
+	tmpDir := t.TempDir()
+
+	// Create a file where we want to create a directory
+	blockingFile := filepath.Join(tmpDir, "test-app")
+	err := os.WriteFile(blockingFile, []byte("blocking"), testFilePerm)
+	require.NoError(t, err)
+
+	// Try to copy template (should fail because test-app is a file, not a directory)
+	err = CopyTemplateFiles(blockingFile, LanguageTypeScript, TemplateSampleApp)
+	require.Error(t, err, "Should fail when destination path is invalid")
+}
+
+func TestCopyTemplateFiles_AllTemplatesForAllLanguages(t *testing.T) {
+	// Comprehensive test that all template/language combinations work
+	for templateKey, templateInfo := range Templates {
+		for _, lang := range templateInfo.Languages {
+			t.Run(lang+"/"+templateKey, func(t *testing.T) {
+				tmpDir := t.TempDir()
+				appPath := filepath.Join(tmpDir, "test-app")
+
+				err := os.MkdirAll(appPath, testDirPerm)
+				require.NoError(t, err)
+
+				err = CopyTemplateFiles(appPath, lang, templateKey)
+				require.NoError(t, err, "Should successfully copy %s/%s template", lang, templateKey)
+
+				// Verify at least some files were created
+				entries, err := os.ReadDir(appPath)
+				require.NoError(t, err)
+				assert.NotEmpty(t, entries, "Template directory should not be empty")
+
+				// Verify .gitignore exists and _gitignore does not
+				gitignorePath := filepath.Join(appPath, ".gitignore")
+				assert.FileExists(t, gitignorePath, ".gitignore should exist")
+
+				underscoreGitignorePath := filepath.Join(appPath, "_gitignore")
+				assert.NoFileExists(t, underscoreGitignorePath, "_gitignore should not exist")
+			})
+		}
+	}
+}
diff --git a/pkg/create/dependencies.go b/pkg/create/dependencies.go
index 6c31417..5e080d2 100644
--- a/pkg/create/dependencies.go
+++ b/pkg/create/dependencies.go
@@ -8,7 +8,11 @@ import (
 )
 
 // InstallDependencies sets up project dependencies based on language
-func InstallDependencies(appName string, appPath string, language string) (string, error) {
+func InstallDependencies(appPath string, ci CreateInput) (string, error) {
+	language := ci.Language
+	template := ci.Template
+	appName := ci.Name
+
 	installCommand, ok := InstallCommands[language]
 	if !ok {
 		return "", fmt.Errorf("unsupported language: %s", language)
@@ -16,7 +20,7 @@ func InstallDependencies(appName string, appPath string, language string) (strin
 
 	requiredTool := RequiredTools[language]
 	if requiredTool != "" && !RequiredTools.CheckToolAvailable(language) {
-		return getNextStepsWithToolInstall(appName, language, requiredTool), nil
+		return getNextStepsWithToolInstall(appName, language, requiredTool, template), nil
 	}
 
 	spinner, _ := pterm.DefaultSpinner.Start(pterm.Sprintf("Setting up %s environment...", language))
@@ -36,16 +40,19 @@ func InstallDependencies(appName string, appPath string, language string) (strin
 			pterm.Println("  uv venv && source .venv/bin/activate && uv sync")
 		}
 		pterm.Println()
-		return getNextStepsStandard(appName), nil
+		return getNextStepsStandard(appName, language, template), nil
 	}
 
 	spinner.Success(pterm.Sprintf("✔ %s environment set up successfully", language))
 
-	return getNextStepsStandard(appName), nil
+	return getNextStepsStandard(appName, language, template), nil
 }
 
 // getNextStepsWithToolInstall returns next steps message including tool installation
-func getNextStepsWithToolInstall(appName string, language string, requiredTool string) string {
+func getNextStepsWithToolInstall(appName string, language string, requiredTool string, template string) string {
+	deployCommand := GetDeployCommand(language, template)
+	invokeCommand := GetInvokeSample(language, template)
+
 	pterm.Warning.Printfln(" %s is not installed or not in PATH", requiredTool)
 
 	switch language {
@@ -63,9 +70,9 @@ func getNextStepsWithToolInstall(appName string, language string, requiredTool s
   # Deploy your app:
   brew install onkernel/tap/kernel
   kernel login  # or: export KERNEL_API_KEY=<YOUR_API_KEY>
-  kernel deploy index.ts
-  kernel invoke ts-basic get-page-title --payload '{"url": "https://www.google.com"}'
-`, appName)
+  %s
+  %s
+`, appName, deployCommand, invokeCommand)
 	case LanguagePython:
 		return pterm.FgYellow.Sprintf(`Next steps:
   # Install uv (choose one):
@@ -80,21 +87,23 @@ func getNextStepsWithToolInstall(appName string, language string, requiredTool s
   # Deploy your app:
   brew install onkernel/tap/kernel
   kernel login  # or: export KERNEL_API_KEY=<YOUR_API_KEY>
-  kernel deploy index.py
-  kernel invoke py-basic get-page-title --payload '{"url": "https://www.google.com"}'
-`, appName)
+  %s
+  %s
+`, appName, deployCommand, invokeCommand)
 	default:
 		return ""
 	}
 }
 
 // getNextStepsStandard returns standard next steps message
-func getNextStepsStandard(appName string) string {
+func getNextStepsStandard(appName string, language string, template string) string {
+	deployCommand := GetDeployCommand(language, template)
+	invokeCommand := GetInvokeSample(language, template)
 	return pterm.FgYellow.Sprintf(`Next steps:
   brew install onkernel/tap/kernel
   cd %s
   kernel login  # or: export KERNEL_API_KEY=<YOUR_API_KEY>
-  kernel deploy index.ts
-  kernel invoke ts-basic get-page-title --payload '{"url": "https://www.google.com"}'
-`, appName)
+  %s
+  %s
+`, appName, deployCommand, invokeCommand)
 }
diff --git a/pkg/create/prompts.go b/pkg/create/prompts.go
index f353982..9747580 100644
--- a/pkg/create/prompts.go
+++ b/pkg/create/prompts.go
@@ -122,3 +122,16 @@ func PromptForTemplate(providedTemplate string, providedLanguage string) (string
 	pterm.Warning.Printfln("Template '%s' not found. Please select from available templates.\n", providedTemplate)
 	return handleTemplatePrompt(templateKVs)
 }
+
+// PromptForOverwrite prompts the user to confirm overwriting an existing directory.
+func PromptForOverwrite(dirName string) (bool, error) {
+	overwrite, err := pterm.DefaultInteractiveConfirm.
+		WithDefaultText(fmt.Sprintf("\nDirectory %s already exists. Overwrite?", dirName)).
+		WithDefaultValue(false).
+		Show()
+	if err != nil {
+		return false, fmt.Errorf("failed to prompt for overwrite: %w", err)
+	}
+
+	return overwrite, nil
+}
diff --git a/pkg/create/templates.go b/pkg/create/templates.go
index 88077cf..6233425 100644
--- a/pkg/create/templates.go
+++ b/pkg/create/templates.go
@@ -6,6 +6,18 @@ import (
 	"sort"
 )
 
+// Template key constants
+const (
+	TemplateSampleApp      = "sample-app"
+	TemplateAdvancedSample = "advanced-sample"
+	TemplateComputerUse    = "computer-use"
+	TemplateCUA            = "cua"
+	TemplateMagnitude      = "magnitude"
+	TemplateGeminiCUA      = "gemini-cua"
+	TemplateBrowserUse     = "browser-use"
+	TemplateStagehand      = "stagehand"
+)
+
 type TemplateInfo struct {
 	Name        string
 	Description string
@@ -20,42 +32,42 @@ type TemplateKeyValue struct {
 type TemplateKeyValues []TemplateKeyValue
 
 var Templates = map[string]TemplateInfo{
-	"sample-app": {
+	TemplateSampleApp: {
 		Name:        "Sample App",
 		Description: "Implements basic Kernel apps",
 		Languages:   []string{LanguageTypeScript, LanguagePython},
 	},
-	"advanced-sample": {
+	TemplateAdvancedSample: {
 		Name:        "Advanced Sample",
 		Description: "Implements sample actions with advanced Kernel configs",
 		Languages:   []string{LanguageTypeScript, LanguagePython},
 	},
-	"computer-use": {
+	TemplateComputerUse: {
 		Name:        "Computer Use",
 		Description: "Implements the Anthropic Computer Use SDK",
 		Languages:   []string{LanguageTypeScript, LanguagePython},
 	},
-	"cua": {
+	TemplateCUA: {
 		Name:        "CUA Sample",
 		Description: "Implements a Computer Use Agent (OpenAI CUA) sample",
 		Languages:   []string{LanguageTypeScript, LanguagePython},
 	},
-	"magnitude": {
+	TemplateMagnitude: {
 		Name:        "Magnitude",
 		Description: "Implements the Magnitude.run SDK",
 		Languages:   []string{LanguageTypeScript},
 	},
-	"gemini-cua": {
+	TemplateGeminiCUA: {
 		Name:        "Gemini CUA",
 		Description: "Implements Gemini 2.5 Computer Use Agent",
 		Languages:   []string{LanguageTypeScript},
 	},
-	"browser-use": {
+	TemplateBrowserUse: {
 		Name:        "Browser Use",
 		Description: "Implements Browser Use SDK",
 		Languages:   []string{LanguagePython},
 	},
-	"stagehand": {
+	TemplateStagehand: {
 		Name:        "Stagehand",
 		Description: "Implements the Stagehand v3 SDK",
 		Languages:   []string{LanguageTypeScript},
@@ -109,3 +121,111 @@ func (tkv TemplateKeyValues) ContainsKey(key string) bool {
 	}
 	return false
 }
+
+type DeployConfig struct {
+	EntryPoint    string
+	EnvVars       []string
+	InvokeCommand string
+}
+
+var Commands = map[string]map[string]DeployConfig{
+	LanguageTypeScript: {
+		TemplateSampleApp: {
+			EntryPoint:    "index.ts",
+			EnvVars:       []string{},
+			InvokeCommand: `kernel invoke ts-basic get-page-title --payload '{"url": "https://www.google.com"}'`,
+		},
+		TemplateAdvancedSample: {
+			EntryPoint:    "index.ts",
+			EnvVars:       []string{},
+			InvokeCommand: "kernel invoke ts-advanced test-captcha-solver",
+		},
+		TemplateStagehand: {
+			EntryPoint:    "index.ts",
+			EnvVars:       []string{"OPENAI_API_KEY=XXX"},
+			InvokeCommand: `kernel invoke ts-stagehand teamsize-task --payload '{"company": "Kernel"}'`,
+		},
+		TemplateComputerUse: {
+			EntryPoint:    "index.ts",
+			EnvVars:       []string{"ANTHROPIC_API_KEY=XXX"},
+			InvokeCommand: `kernel invoke ts-cu cu-task --payload '{"query": "Return the first url of a search result for NYC restaurant reviews Pete Wells"}'`,
+		},
+		TemplateMagnitude: {
+			EntryPoint:    "index.ts",
+			EnvVars:       []string{"ANTHROPIC_API_KEY=XXX"},
+			InvokeCommand: `kernel invoke ts-magnitude mag-url-extract --payload '{"url": "https://en.wikipedia.org/wiki/Special:Random"}'`,
+		},
+		TemplateCUA: {
+			EntryPoint:    "index.ts",
+			EnvVars:       []string{"OPENAI_API_KEY=XXX"},
+			InvokeCommand: `kernel invoke ts-cua cua-task --payload '{"task": "Go to https://news.ycombinator.com and get the top 5 articles"}'`,
+		},
+		TemplateGeminiCUA: {
+			EntryPoint:    "index.ts",
+			EnvVars:       []string{"GOOGLE_API_KEY=XXX", "OPENAI_API_KEY=XXX"},
+			InvokeCommand: "kernel invoke ts-gemini-cua gemini-cua-task",
+		},
+	},
+	LanguagePython: {
+		TemplateSampleApp: {
+			EntryPoint:    "main.py",
+			EnvVars:       []string{},
+			InvokeCommand: `kernel invoke python-basic get-page-title --payload '{"url": "https://www.google.com"}'`,
+		},
+		TemplateAdvancedSample: {
+			EntryPoint:    "main.py",
+			EnvVars:       []string{},
+			InvokeCommand: "kernel invoke python-advanced test-captcha-solver",
+		},
+		TemplateBrowserUse: {
+			EntryPoint:    "main.py",
+			EnvVars:       []string{"OPENAI_API_KEY=XXX"},
+			InvokeCommand: `kernel invoke python-bu bu-task --payload '{"task": "Compare the price of gpt-4o and DeepSeek-V3"}'`,
+		},
+		TemplateComputerUse: {
+			EntryPoint:    "main.py",
+			EnvVars:       []string{"ANTHROPIC_API_KEY=XXX"},
+			InvokeCommand: `kernel invoke python-cu cu-task --payload '{"query": "Return the first url of a search result for NYC restaurant reviews Pete Wells"}'`,
+		},
+		TemplateCUA: {
+			EntryPoint:    "main.py",
+			EnvVars:       []string{"OPENAI_API_KEY=XXX"},
+			InvokeCommand: `kernel invoke python-cua cua-task --payload '{"task": "Go to https://news.ycombinator.com and get the top 5 articles"}'`,
+		},
+	},
+}
+
+// GetDeployCommand returns the full deploy command string for a given language and template
+func GetDeployCommand(language, template string) string {
+	langCommands, ok := Commands[language]
+	if !ok {
+		return ""
+	}
+
+	config, ok := langCommands[template]
+	if !ok {
+		return ""
+	}
+
+	cmd := "kernel deploy " + config.EntryPoint
+	for _, env := range config.EnvVars {
+		cmd += " --env " + env
+	}
+
+	return cmd
+}
+
+// GetInvokeSample returns the sample invoke command for a given language and template
+func GetInvokeSample(language, template string) string {
+	langSamples, ok := Commands[language]
+	if !ok {
+		return ""
+	}
+
+	config, ok := langSamples[template]
+	if !ok {
+		return ""
+	}
+
+	return config.InvokeCommand
+}
diff --git a/pkg/create/types.go b/pkg/create/types.go
index 67939b7..05e76bc 100644
--- a/pkg/create/types.go
+++ b/pkg/create/types.go
@@ -2,6 +2,12 @@ package create
 
 import "os/exec"
 
+type CreateInput struct {
+	Name     string
+	Language string
+	Template string
+}
+
 const (
 	DefaultAppName = "my-kernel-app"
 	AppNamePrompt  = "What is the name of your project?"