diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index bf1819f..df2eb36 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -44,7 +44,7 @@ jobs:
       - name: 🔵 Setup Go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.24.x
+          go-version: 1.25.x
 
       - name: ⏬ Install Dependencies
         run: go get .
diff --git a/cmd/config/config.go b/cmd/config/config.go
deleted file mode 100644
index e59560e..0000000
--- a/cmd/config/config.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package config
-
-import (
-	"github.com/kloudkit/ws-cli/cmd/config/copy"
-	"github.com/spf13/cobra"
-)
-
-var ConfigCmd = &cobra.Command{
-	Use:   "config",
-	Short: "Interact with workspace related configurations",
-}
-
-func init() {
-	ConfigCmd.AddCommand(copy.CopyCmd)
-}
diff --git a/cmd/config/copy/copy.go b/cmd/config/copy/copy.go
deleted file mode 100644
index b7f78a0..0000000
--- a/cmd/config/copy/copy.go
+++ /dev/null
@@ -1,105 +0,0 @@
-package copy
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-
-	"github.com/kloudkit/ws-cli/internals/path"
-	"github.com/spf13/cobra"
-)
-
-type config struct {
-	SourcePath string
-	OutputName string
-}
-
-var configs = map[string]config{
-	"markdownlint": {
-		SourcePath: ".config/markdownlint/config",
-		OutputName: ".markdownlint.json",
-	},
-	"ruff": {
-		SourcePath: ".config/ruff/ruff.toml",
-		OutputName: ".ruff.toml",
-	},
-	"yamllint": {
-		SourcePath: ".config/yamllint/config",
-		OutputName: ".yamllint",
-	},
-}
-
-var CopyCmd = &cobra.Command{
-	Use:   "cp",
-	Short: "Copying workspace defined configurations to a project",
-}
-
-func copy(source, dest string) error {
-	stats, err := os.Stat(source)
-	if err != nil {
-		return err
-	}
-
-	if !stats.Mode().IsRegular() {
-		return fmt.Errorf("%s is not a regular file", source)
-	}
-
-	sourceFile, err := os.Open(source)
-	if err != nil {
-		return err
-	}
-	defer sourceFile.Close()
-
-	destFile, err := os.Create(dest)
-	if err != nil {
-		fmt.Println(err)
-		return err
-	}
-	defer destFile.Close()
-
-	_, err = io.Copy(destFile, sourceFile)
-
-	return err
-}
-
-func createCommand(key string) *cobra.Command {
-	config := configs[key]
-
-	return &cobra.Command{
-		Use:   key,
-		Short: fmt.Sprintf("Copy %s configuration to the project", key),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			dest, _ := cmd.Flags().GetString("dest")
-			force, _ := cmd.Flags().GetBool("force")
-
-			source := path.GetHomeDirectory(config.SourcePath)
-
-			dest, _ = filepath.Abs(dest)
-			dest = path.AppendSegments(dest, config.OutputName)
-
-			if !path.CanOverride(dest, force) {
-				return fmt.Errorf("the file [%s] already exists", dest)
-			}
-
-			if err := copy(source, dest); err != nil {
-				return fmt.Errorf("the file [%s] could not be written", dest)
-			}
-
-			fmt.Fprintf(cmd.OutOrStdout(), "Copied [%s] to [%s]\n", source, dest)
-
-			return nil
-		},
-	}
-}
-
-func init() {
-	CopyCmd.PersistentFlags().String("dest", ".", "Output directory")
-	CopyCmd.PersistentFlags().BoolP("force", "f", false, "Force the overwriting of an existing file")
-
-	CopyCmd.AddCommand(
-		createCommand("markdownlint"),
-		createCommand("ruff"),
-		createCommand("yamllint"),
-	)
-}
diff --git a/cmd/info/env.go b/cmd/info/env.go
index 6b6d5e1..ea439ab 100644
--- a/cmd/info/env.go
+++ b/cmd/info/env.go
@@ -12,7 +12,7 @@ import (
 )
 
 func showEnvironment(writer io.Writer) {
-	fmt.Fprintln(writer, styles.HeaderStyle().Render("Environment Variables"))
+	fmt.Fprintln(writer, styles.Header().Render("Environment Variables"))
 
 	var envVars [][]string
 	for key, value := range env.GetAll() {
@@ -22,7 +22,7 @@ func showEnvironment(writer io.Writer) {
 	}
 
 	if len(envVars) == 0 {
-		fmt.Fprintln(writer, styles.WarningStyle().Render("  No environment variables found"))
+		fmt.Fprintln(writer, styles.Warning().Render("  No environment variables found"))
 		return
 	}
 
diff --git a/cmd/info/extensions.go b/cmd/info/extensions.go
index adf1adc..cef8b8d 100644
--- a/cmd/info/extensions.go
+++ b/cmd/info/extensions.go
@@ -30,7 +30,7 @@ func fetchExtensions() [][]string {
 }
 
 func showExtensions(writer io.Writer) {
-	fmt.Fprintln(writer, styles.HeaderStyle().Render("Extensions"))
+	fmt.Fprintln(writer, styles.Header().Render("Extensions"))
 	fmt.Fprintln(writer)
 
 	t := styles.Table("Name", "Version").
diff --git a/cmd/info/info.go b/cmd/info/info.go
index fb622b1..2b4c3f3 100644
--- a/cmd/info/info.go
+++ b/cmd/info/info.go
@@ -44,7 +44,7 @@ func readJson(content map[string]any, key string) string {
 func showVersion(writer io.Writer) {
 	content := readJsonFile()
 
-	fmt.Fprintln(writer, styles.HeaderStyle().Render("Versions"))
+	fmt.Fprintln(writer, styles.Header().Render("Versions"))
 	fmt.Fprintln(writer)
 
 	t := styles.Table("", "Value").
diff --git a/cmd/info/uptime.go b/cmd/info/uptime.go
index e863a0a..573dcd3 100644
--- a/cmd/info/uptime.go
+++ b/cmd/info/uptime.go
@@ -54,7 +54,7 @@ func humanizeDuration(duration time.Duration) string {
 func showUptime(writer io.Writer) {
 	started, running, _ := readStartup()
 
-	fmt.Fprintln(writer, styles.HeaderStyle().Render("Uptime"))
+	fmt.Fprintln(writer, styles.Header().Render("Uptime"))
 	fmt.Fprintln(writer)
 
 	t := styles.Table("", "Value").
diff --git a/cmd/logs/logs.go b/cmd/logs/logs.go
index 29a20d0..a2f18e0 100644
--- a/cmd/logs/logs.go
+++ b/cmd/logs/logs.go
@@ -22,13 +22,13 @@ func execute(cmd *cobra.Command, args []string) {
 	level, _ := cmd.Flags().GetString("level")
 
 	if level != "" && level != "info" && level != "warn" && level != "error" && level != "debug" {
-		fmt.Fprintln(cmd.ErrOrStderr(), styles.ErrorStyle().Render("Invalid log level. Must be one of: debug, info, warn, error"))
+		fmt.Fprintln(cmd.ErrOrStderr(), styles.Error().Render("Invalid log level. Must be one of: debug, info, warn, error"))
 		os.Exit(1)
 	}
 
 	reader, err := logger.NewReader(tail, level)
 	if err != nil {
-		fmt.Fprintln(cmd.ErrOrStderr(), styles.ErrorStyle().Render(fmt.Sprintf("Error: %s", err)))
+		fmt.Fprintln(cmd.ErrOrStderr(), styles.Error().Render(fmt.Sprintf("Error: %s", err)))
 		os.Exit(1)
 	}
 
@@ -39,7 +39,7 @@ func execute(cmd *cobra.Command, args []string) {
 	}
 
 	if err != nil {
-		fmt.Fprintln(cmd.ErrOrStderr(), styles.ErrorStyle().Render(fmt.Sprintf("Error reading logs: %s", err)))
+		fmt.Fprintln(cmd.ErrOrStderr(), styles.Error().Render(fmt.Sprintf("Error reading logs: %s", err)))
 		os.Exit(1)
 	}
 }
diff --git a/cmd/root.go b/cmd/root.go
index e32bbd8..8974e98 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -5,13 +5,13 @@ import (
 	"os"
 
 	"github.com/kloudkit/ws-cli/cmd/clip"
-	"github.com/kloudkit/ws-cli/cmd/config"
 	"github.com/kloudkit/ws-cli/cmd/feature"
 	"github.com/kloudkit/ws-cli/cmd/info"
 	"github.com/kloudkit/ws-cli/cmd/log"
 	"github.com/kloudkit/ws-cli/cmd/logs"
 	"github.com/kloudkit/ws-cli/cmd/serve"
 	"github.com/kloudkit/ws-cli/cmd/show"
+	"github.com/kloudkit/ws-cli/cmd/template"
 	"github.com/kloudkit/ws-cli/internals/styles"
 	"github.com/spf13/cobra"
 )
@@ -55,10 +55,10 @@ func init() {
 
 	rootCmd.AddCommand(
 		clip.ClipCmd,
-		config.ConfigCmd,
 		feature.FeatureCmd,
 		serve.ServeCmd,
 		show.ShowCmd,
+		template.TemplateCmd,
 		info.InfoCmd,
 		log.LogCmd,
 		logs.LogsCmd,
diff --git a/cmd/show/ip.go b/cmd/show/ip.go
index 73b301e..a224e08 100644
--- a/cmd/show/ip.go
+++ b/cmd/show/ip.go
@@ -20,7 +20,7 @@ var ipInternalCmd = &cobra.Command{
 		ip, err := net.GetInternalIP()
 
 		if err == nil {
-			fmt.Fprintln(cmd.OutOrStdout(), styles.ValueStyle().Render(ip))
+			fmt.Fprintln(cmd.OutOrStdout(), styles.Value().Render(ip))
 		}
 
 		return err
@@ -34,7 +34,7 @@ var ipNodeCmd = &cobra.Command{
 		ip, err := net.GetNodeIP()
 
 		if err == nil {
-			fmt.Fprintln(cmd.OutOrStdout(), styles.ValueStyle().Render(ip))
+			fmt.Fprintln(cmd.OutOrStdout(), styles.Value().Render(ip))
 		}
 
 		return err
@@ -43,4 +43,6 @@ var ipNodeCmd = &cobra.Command{
 
 func init() {
 	ipCmd.AddCommand(ipInternalCmd, ipNodeCmd)
+
+	ShowCmd.AddCommand(ipCmd)
 }
diff --git a/cmd/show/path.go b/cmd/show/path.go
index cf833f3..3e9c9e0 100644
--- a/cmd/show/path.go
+++ b/cmd/show/path.go
@@ -20,7 +20,7 @@ var pathHomeCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		fmt.Fprintln(
 			cmd.OutOrStdout(),
-			styles.ValueStyle().Render(env.String("WS_SERVER_ROOT", "/workspace")),
+			styles.Value().Render(env.String("WS_SERVER_ROOT", "/workspace")),
 		)
 	},
 }
@@ -37,7 +37,7 @@ var pathVscodeCmd = &cobra.Command{
 			settingsPath = path.GetHomeDirectory("/.local/share/code-server/User/settings.json")
 		}
 
-		fmt.Fprintln(cmd.OutOrStdout(), styles.ValueStyle().Render(settingsPath))
+		fmt.Fprintln(cmd.OutOrStdout(), styles.Value().Render(settingsPath))
 	},
 }
 
@@ -45,4 +45,6 @@ func init() {
 	pathVscodeCmd.Flags().Bool("workspace", false, "Get the workspace settings")
 
 	pathCmd.AddCommand(pathHomeCmd, pathVscodeCmd)
+
+	ShowCmd.AddCommand(pathCmd)
 }
diff --git a/cmd/show/show.go b/cmd/show/show.go
index f8990d5..f46900f 100644
--- a/cmd/show/show.go
+++ b/cmd/show/show.go
@@ -8,7 +8,3 @@ var ShowCmd = &cobra.Command{
 	Use:   "show",
 	Short: "Show information about the current workspace instance",
 }
-
-func init() {
-	ShowCmd.AddCommand(pathCmd, ipCmd)
-}
diff --git a/cmd/template/apply.go b/cmd/template/apply.go
new file mode 100644
index 0000000..44b835d
--- /dev/null
+++ b/cmd/template/apply.go
@@ -0,0 +1,50 @@
+package template
+
+import (
+	"fmt"
+
+	"github.com/kloudkit/ws-cli/internals/styles"
+	"github.com/kloudkit/ws-cli/internals/template"
+	"github.com/spf13/cobra"
+)
+
+var applyCmd = &cobra.Command{
+	Use:               "apply <template>",
+	Short:             "Apply a configuration template to the current project",
+	Args:              cobra.ExactArgs(1),
+	ValidArgsFunction: templateCompletion,
+	RunE:              runApply,
+}
+
+func runApply(cmd *cobra.Command, args []string) error {
+	templateName := args[0]
+	targetPath, _ := cmd.Flags().GetString("path")
+	force, _ := cmd.Flags().GetBool("force")
+
+	if err := template.ApplyTemplate(templateName, targetPath, force); err != nil {
+		return err
+	}
+
+	config, _ := template.GetTemplate(templateName)
+	sourcePath := template.SupportedTemplates[templateName].SourcePath
+
+	fmt.Fprintf(cmd.OutOrStdout(), "%s\n", styles.Success().Render("Template applied successfully:"))
+	fmt.Fprintf(cmd.OutOrStdout(), "  %s %s\n", styles.Key().Render("Source:"), sourcePath)
+	fmt.Fprintf(cmd.OutOrStdout(), "  %s %s/%s\n", styles.Key().Render("Target:"), targetPath, config.OutputName)
+
+	return nil
+}
+
+func templateCompletion(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	if len(args) != 0 {
+		return nil, cobra.ShellCompDirectiveNoFileComp
+	}
+	return template.GetTemplateNames(), cobra.ShellCompDirectiveNoFileComp
+}
+
+func init() {
+	applyCmd.Flags().String("path", ".", "Target directory path")
+	applyCmd.Flags().BoolP("force", "f", false, "Overwrite existing files")
+
+	TemplateCmd.AddCommand(applyCmd)
+}
diff --git a/cmd/template/list.go b/cmd/template/list.go
new file mode 100644
index 0000000..6bfefb6
--- /dev/null
+++ b/cmd/template/list.go
@@ -0,0 +1,43 @@
+package template
+
+import (
+	"fmt"
+
+	"github.com/kloudkit/ws-cli/internals/path"
+	"github.com/kloudkit/ws-cli/internals/styles"
+	"github.com/kloudkit/ws-cli/internals/template"
+	"github.com/spf13/cobra"
+)
+
+var listCmd = &cobra.Command{
+	Use:     "list",
+	Short:   "List all available configuration templates",
+	Aliases: []string{"ls"},
+	RunE:    runList,
+}
+
+func runList(cmd *cobra.Command, args []string) error {
+	templates := template.SupportedTemplates
+	names := template.GetTemplateNames()
+
+	listItems := make([]any, len(names))
+	for i, name := range names {
+		config := templates[name]
+		resolvedPath := path.ResolveConfigPath(config.SourcePath)
+		location := styles.Muted().Render(fmt.Sprintf("(%s)", path.ShortenHomePath(resolvedPath)))
+		listItems[i] = fmt.Sprintf("%s %s", styles.Key().Render(name), location)
+	}
+
+	l := styles.List(listItems...)
+
+	fmt.Fprintf(cmd.OutOrStdout(), "%s\n\n", styles.Success().Render("Available Templates"))
+	fmt.Fprintf(cmd.OutOrStdout(), "%s\n\n", l.String())
+	fmt.Fprintf(cmd.OutOrStdout(), "%s\n", styles.Muted().Render("Use 'ws-cli template apply <name>' to apply a template"))
+	fmt.Fprintf(cmd.OutOrStdout(), "%s\n", styles.Muted().Render("Use 'ws-cli template show <name>' to view template contents"))
+
+	return nil
+}
+
+func init() {
+	TemplateCmd.AddCommand(listCmd)
+}
diff --git a/cmd/template/show.go b/cmd/template/show.go
new file mode 100644
index 0000000..f4ebb82
--- /dev/null
+++ b/cmd/template/show.go
@@ -0,0 +1,55 @@
+package template
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/kloudkit/ws-cli/internals/styles"
+	"github.com/kloudkit/ws-cli/internals/template"
+	"github.com/spf13/cobra"
+)
+
+var showCmd = &cobra.Command{
+	Use:   "show <template>",
+	Short: "Display the contents of a configuration template",
+	Long: fmt.Sprintf(`Display the contents of a configuration template.
+
+Available templates: %s`, strings.Join(template.GetTemplateNames(), ", ")),
+	Args:              cobra.ExactArgs(1),
+	ValidArgsFunction: templateCompletion,
+	RunE:              runShow,
+}
+
+func init() {
+	showCmd.Flags().Bool("local", false, "Show the local version of the template (if applied)")
+
+	TemplateCmd.AddCommand(showCmd)
+}
+
+func runShow(cmd *cobra.Command, args []string) error {
+	templateName := args[0]
+	local, _ := cmd.Flags().GetBool("local")
+
+	content, err := template.ShowTemplate(templateName, local)
+	if err != nil {
+		return err
+	}
+
+	if styles.ColorEnabled {
+		if local {
+			fmt.Fprintf(cmd.OutOrStdout(), "%sLocal template '%s':%s\n\n", styles.ColorHeader, templateName, styles.ColorText)
+		} else {
+			fmt.Fprintf(cmd.OutOrStdout(), "%sTemplate '%s':%s\n\n", styles.ColorHeader, templateName, styles.ColorText)
+		}
+		fmt.Fprintf(cmd.OutOrStdout(), "%s%s%s\n", styles.ColorMuted, content, styles.ColorText)
+	} else {
+		if local {
+			fmt.Fprintf(cmd.OutOrStdout(), "Local template '%s':\n\n", templateName)
+		} else {
+			fmt.Fprintf(cmd.OutOrStdout(), "Template '%s':\n\n", templateName)
+		}
+		fmt.Fprintf(cmd.OutOrStdout(), "%s\n", content)
+	}
+
+	return nil
+}
diff --git a/cmd/template/template.go b/cmd/template/template.go
new file mode 100644
index 0000000..ea366af
--- /dev/null
+++ b/cmd/template/template.go
@@ -0,0 +1,11 @@
+package template
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var TemplateCmd = &cobra.Command{
+	Use:   "template",
+	Short: "Manage static configuration files",
+	Long:  "Copy and manage configuration files stored in global locations",
+}
diff --git a/internals/logger/logger.go b/internals/logger/logger.go
index 92b41c1..5b5c2b0 100644
--- a/internals/logger/logger.go
+++ b/internals/logger/logger.go
@@ -19,10 +19,10 @@ var (
 	logRegex   = regexp.MustCompile(`^\[.*?\]\s+(\w+)\s*(.*)$`)
 	timeFormat = "[2006-01-02T15:04:05.000Z]"
 	styleMap   = map[string]lipgloss.Style{
-		"info":  styles.InfoStyle(),
-		"error": styles.ErrorStyle(),
-		"warn":  styles.WarningStyle(),
-		"debug": styles.MutedStyle(),
+		"info":  styles.Info(),
+		"error": styles.Error(),
+		"warn":  styles.Warning(),
+		"debug": styles.Muted(),
 	}
 )
 
diff --git a/internals/path/support.go b/internals/path/support.go
index 0c030e9..4585709 100644
--- a/internals/path/support.go
+++ b/internals/path/support.go
@@ -1,6 +1,8 @@
 package path
 
 import (
+	"fmt"
+	"io"
 	"os"
 	"regexp"
 	"strings"
@@ -34,3 +36,65 @@ func CanOverride(path_ string, force bool) bool {
 
 	return false
 }
+
+func ResolveConfigPath(configPath string) string {
+	if strings.HasPrefix(configPath, "/") {
+		return configPath
+	}
+
+	return GetHomeDirectory(configPath)
+}
+
+func FileExists(path_ string) bool {
+	_, err := os.Stat(path_)
+
+	return !os.IsNotExist(err)
+}
+
+func GetCurrentWorkingDirectory(segments ...string) (string, error) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("failed to get current directory: %w", err)
+	}
+	return AppendSegments(cwd, segments...), nil
+}
+
+func CopyFile(source, dest string) error {
+	stats, err := os.Stat(source)
+	if err != nil {
+		return fmt.Errorf("failed to stat source file: %w", err)
+	}
+
+	if !stats.Mode().IsRegular() {
+		return fmt.Errorf("%s is not a regular file", source)
+	}
+
+	sourceFile, err := os.Open(source)
+	if err != nil {
+		return fmt.Errorf("failed to open source file: %w", err)
+	}
+	defer sourceFile.Close()
+
+	destFile, err := os.Create(dest)
+	if err != nil {
+		return fmt.Errorf("failed to create destination file: %w", err)
+	}
+	defer destFile.Close()
+
+	_, err = io.Copy(destFile, sourceFile)
+	if err != nil {
+		return fmt.Errorf("failed to copy file: %w", err)
+	}
+
+	return nil
+}
+
+func ShortenHomePath(path_ string) string {
+	homeDir := GetHomeDirectory()
+
+	if after, ok := strings.CutPrefix(path_, homeDir); ok {
+		return "~" + after
+	}
+
+	return path_
+}
diff --git a/internals/path/support_test.go b/internals/path/support_test.go
index bc2cc35..701b24e 100644
--- a/internals/path/support_test.go
+++ b/internals/path/support_test.go
@@ -31,3 +31,94 @@ func TestGetHomeDirectory(t *testing.T) {
 		assert.Equal(t, "/home/kloud", path.GetHomeDirectory())
 	})
 }
+
+func TestResolveConfigPath(t *testing.T) {
+	t.Run("AbsolutePath", func(t *testing.T) {
+		result := path.ResolveConfigPath("/etc/config")
+		assert.Equal(t, "/etc/config", result)
+	})
+
+	t.Run("RelativePath", func(t *testing.T) {
+		t.Setenv("HOME", "/home/user")
+		result := path.ResolveConfigPath(".config/app/config")
+		assert.Equal(t, "/home/user/.config/app/config", result)
+	})
+}
+
+func TestFileExists(t *testing.T) {
+	t.Run("ExistingFile", func(t *testing.T) {
+		tempDir := t.TempDir()
+		testFile := path.AppendSegments(tempDir, "test.txt")
+
+		err := os.WriteFile(testFile, []byte("test"), 0644)
+		assert.NilError(t, err)
+
+		assert.Assert(t, path.FileExists(testFile))
+	})
+
+	t.Run("NonExistentFile", func(t *testing.T) {
+		result := path.FileExists("/non/existent/file")
+		assert.Assert(t, !result)
+	})
+}
+
+func TestGetCurrentWorkingDirectory(t *testing.T) {
+	t.Run("WithoutSegments", func(t *testing.T) {
+		result, err := path.GetCurrentWorkingDirectory()
+		assert.NilError(t, err)
+
+		cwd, err := os.Getwd()
+		assert.NilError(t, err)
+		assert.Equal(t, result, cwd)
+	})
+
+	t.Run("WithSegments", func(t *testing.T) {
+		result, err := path.GetCurrentWorkingDirectory("sub", "path")
+		assert.NilError(t, err)
+
+		cwd, err := os.Getwd()
+		assert.NilError(t, err)
+		expected := path.AppendSegments(cwd, "sub", "path")
+		assert.Equal(t, result, expected)
+	})
+}
+
+func TestCopyFile(t *testing.T) {
+	t.Run("SuccessfulCopy", func(t *testing.T) {
+		tempDir := t.TempDir()
+		sourceFile := path.AppendSegments(tempDir, "source.txt")
+		destFile := path.AppendSegments(tempDir, "dest.txt")
+		content := "test content"
+
+		err := os.WriteFile(sourceFile, []byte(content), 0644)
+		assert.NilError(t, err)
+
+		err = path.CopyFile(sourceFile, destFile)
+		assert.NilError(t, err)
+
+		destContent, err := os.ReadFile(destFile)
+		assert.NilError(t, err)
+		assert.Equal(t, string(destContent), content)
+	})
+
+	t.Run("NonExistentSource", func(t *testing.T) {
+		tempDir := t.TempDir()
+		sourceFile := path.AppendSegments(tempDir, "nonexistent.txt")
+		destFile := path.AppendSegments(tempDir, "dest.txt")
+
+		err := path.CopyFile(sourceFile, destFile)
+		assert.ErrorContains(t, err, "failed to stat source file")
+	})
+
+	t.Run("DirectoryAsSource", func(t *testing.T) {
+		tempDir := t.TempDir()
+		sourceDir := path.AppendSegments(tempDir, "sourcedir")
+		destFile := path.AppendSegments(tempDir, "dest.txt")
+
+		err := os.Mkdir(sourceDir, 0755)
+		assert.NilError(t, err)
+
+		err = path.CopyFile(sourceDir, destFile)
+		assert.ErrorContains(t, err, "is not a regular file")
+	})
+}
diff --git a/internals/server/server.go b/internals/server/server.go
index 5327113..c70bded 100644
--- a/internals/server/server.go
+++ b/internals/server/server.go
@@ -21,8 +21,8 @@ func ServeDirectory(config Config, directory string, description string) error {
 
 	handler := http.FileServer(http.Dir(directory))
 
-	fmt.Println(styles.SuccessStyle().Render(fmt.Sprintf("Serving %s at port %d", description, config.Port)))
-	fmt.Println(styles.InfoStyle().Render("To stop serving, press Ctrl+C"))
+	fmt.Println(styles.Success().Render(fmt.Sprintf("Serving %s at port %d", description, config.Port)))
+	fmt.Println(styles.Info().Render("To stop serving, press Ctrl+C"))
 
 	return http.ListenAndServe(host, handler)
 }
diff --git a/internals/styles/list.go b/internals/styles/list.go
new file mode 100644
index 0000000..91f9b72
--- /dev/null
+++ b/internals/styles/list.go
@@ -0,0 +1,35 @@
+package styles
+
+import (
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/list"
+)
+
+func ListStyle() lipgloss.Style {
+	return WithColor(
+		lipgloss.NewStyle().Foreground(lipgloss.Color(ColorText)),
+	)
+}
+
+func ListEnumeratorStyle() lipgloss.Style {
+	return WithColor(Muted()).PaddingRight(2)
+}
+
+func ListItemStyle() lipgloss.Style {
+	return WithColor(
+		lipgloss.NewStyle().Foreground(lipgloss.Color(ColorText)),
+	)
+}
+
+func List(items ...any) *list.List {
+	l := list.New(items...)
+	l.Enumerator(list.Bullet)
+	l.EnumeratorStyle(ListEnumeratorStyle())
+	l.ItemStyle(ListItemStyle())
+
+	return l
+}
+
+func NumberedList(items ...any) *list.List {
+	return List(items...).Enumerator(list.Arabic)
+}
diff --git a/internals/styles/styles.go b/internals/styles/styles.go
index 302e3af..bc2da0b 100644
--- a/internals/styles/styles.go
+++ b/internals/styles/styles.go
@@ -2,7 +2,7 @@ package styles
 
 import "github.com/charmbracelet/lipgloss"
 
-func HeaderStyle() lipgloss.Style {
+func Header() lipgloss.Style {
 	return WithColor(
 		lipgloss.NewStyle().
 			Foreground(lipgloss.Color(ColorHeader)).
@@ -10,7 +10,7 @@ func HeaderStyle() lipgloss.Style {
 	)
 }
 
-func SubHeaderStyle() lipgloss.Style {
+func SubHeader() lipgloss.Style {
 	return WithColor(
 		lipgloss.NewStyle().
 			Foreground(lipgloss.Color(ColorInfo)).
@@ -18,43 +18,43 @@ func SubHeaderStyle() lipgloss.Style {
 	)
 }
 
-func KeyStyle() lipgloss.Style {
+func Key() lipgloss.Style {
 	return WithColor(
 		lipgloss.NewStyle().Foreground(lipgloss.Color(ColorAccent)),
 	)
 }
 
-func ValueStyle() lipgloss.Style {
+func Value() lipgloss.Style {
 	return WithColor(
 		lipgloss.NewStyle().Foreground(lipgloss.Color(ColorText)),
 	)
 }
 
-func InfoStyle() lipgloss.Style {
+func Info() lipgloss.Style {
 	return WithColor(
 		lipgloss.NewStyle().Foreground(lipgloss.Color(ColorInfo)),
 	)
 }
 
-func SuccessStyle() lipgloss.Style {
+func Success() lipgloss.Style {
 	return WithColor(
 		lipgloss.NewStyle().Foreground(lipgloss.Color(ColorSuccess)),
 	)
 }
 
-func WarningStyle() lipgloss.Style {
+func Warning() lipgloss.Style {
 	return WithColor(
 		lipgloss.NewStyle().Foreground(lipgloss.Color(ColorWarning)),
 	)
 }
 
-func ErrorStyle() lipgloss.Style {
+func Error() lipgloss.Style {
 	return WithColor(
 		lipgloss.NewStyle().Foreground(lipgloss.Color(ColorError)),
 	)
 }
 
-func MutedStyle() lipgloss.Style {
+func Muted() lipgloss.Style {
 	return WithColor(
 		lipgloss.NewStyle().Foreground(lipgloss.Color(ColorMuted)),
 	)
diff --git a/internals/styles/table.go b/internals/styles/table.go
index 15016ee..6fb0cdd 100644
--- a/internals/styles/table.go
+++ b/internals/styles/table.go
@@ -13,7 +13,7 @@ func TableBorderStyle() lipgloss.Style {
 
 func TableHeaderStyle() lipgloss.Style {
 	return WithColor(
-		HeaderStyle().
+		Header().
 			Align(lipgloss.Center).
 			PaddingLeft(1).
 			PaddingRight(1),
@@ -35,7 +35,7 @@ func TableCellStyle() lipgloss.Style {
 
 func TableKeyCellStyle() lipgloss.Style {
 	return WithColor(
-		KeyStyle().
+		Key().
 			PaddingLeft(1).
 			PaddingRight(1),
 		TableCellStyle(),
diff --git a/internals/template/template.go b/internals/template/template.go
new file mode 100644
index 0000000..0e7df22
--- /dev/null
+++ b/internals/template/template.go
@@ -0,0 +1,100 @@
+package template
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/kloudkit/ws-cli/internals/path"
+)
+
+type Config struct {
+	SourcePath string
+	OutputName string
+}
+
+var SupportedTemplates = map[string]Config{
+	"ansible": {
+		SourcePath: "/etc/ansible/ansible.cfg",
+		OutputName: "ansible.cfg",
+	},
+	"markdownlint": {
+		SourcePath: ".config/markdownlint/config",
+		OutputName: ".markdownlint.json",
+	},
+	"ruff": {
+		SourcePath: ".config/ruff/ruff.toml",
+		OutputName: ".ruff.toml",
+	},
+	"yamllint": {
+		SourcePath: ".config/yamllint/config",
+		OutputName: ".yamllint",
+	},
+}
+
+func GetTemplate(name string) (Config, bool) {
+	config, exists := SupportedTemplates[name]
+
+	return config, exists
+}
+
+func GetTemplateNames() []string {
+	names := make([]string, 0, len(SupportedTemplates))
+
+	for name := range SupportedTemplates {
+		names = append(names, name)
+	}
+
+	return names
+}
+
+func ApplyTemplate(name, targetPath string, force bool) error {
+	config, exists := GetTemplate(name)
+	if !exists {
+		return fmt.Errorf("template '%s' not found", name)
+	}
+
+	sourcePath := path.ResolveConfigPath(config.SourcePath)
+
+	if !path.FileExists(sourcePath) {
+		return fmt.Errorf("template source file not found: %s", sourcePath)
+	}
+
+	targetPath, err := filepath.Abs(targetPath)
+	if err != nil {
+		return fmt.Errorf("invalid target path: %w", err)
+	}
+
+	destPath := path.AppendSegments(targetPath, config.OutputName)
+
+	if !path.CanOverride(destPath, force) {
+		return fmt.Errorf("file already exists: %s (use --force to overwrite)", destPath)
+	}
+
+	return path.CopyFile(sourcePath, destPath)
+}
+
+func ShowTemplate(name string, local bool) (string, error) {
+	config, exists := GetTemplate(name)
+	if !exists {
+		return "", fmt.Errorf("template '%s' not found", name)
+	}
+
+	var sourcePath string
+	var err error
+	if local {
+		sourcePath, err = path.GetCurrentWorkingDirectory(config.OutputName)
+		if err != nil {
+			return "", err
+		}
+	} else {
+		sourcePath = path.ResolveConfigPath(config.SourcePath)
+	}
+
+	content, err := os.ReadFile(sourcePath)
+	if err != nil {
+		return "", fmt.Errorf("failed to read template: %w", err)
+	}
+
+	return string(content), nil
+}
diff --git a/internals/template/template_test.go b/internals/template/template_test.go
new file mode 100644
index 0000000..8c3f789
--- /dev/null
+++ b/internals/template/template_test.go
@@ -0,0 +1,135 @@
+package template
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestGetTemplate(t *testing.T) {
+	config, exists := GetTemplate("markdownlint")
+	assert.Assert(t, exists, "markdownlint template should exist")
+	assert.Equal(t, config.SourcePath, ".config/markdownlint/config")
+	assert.Equal(t, config.OutputName, ".markdownlint.json")
+
+	_, exists = GetTemplate("nonexistent")
+	assert.Assert(t, !exists, "nonexistent template should not exist")
+}
+
+func TestGetTemplateNames(t *testing.T) {
+	names := GetTemplateNames()
+	expectedNames := []string{"ansible", "markdownlint", "ruff", "yamllint"}
+
+	assert.Equal(t, len(names), len(expectedNames))
+
+	nameSet := make(map[string]bool)
+	for _, name := range names {
+		nameSet[name] = true
+	}
+
+	for _, expected := range expectedNames {
+		assert.Assert(t, nameSet[expected], "expected template name '%s' not found", expected)
+	}
+}
+
+func TestApplyTemplate(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "template_test")
+	assert.NilError(t, err)
+	defer os.RemoveAll(tempDir)
+
+	sourceDir := filepath.Join(tempDir, ".config", "markdownlint")
+	err = os.MkdirAll(sourceDir, 0755)
+	assert.NilError(t, err)
+
+	sourceFile := filepath.Join(sourceDir, "config")
+	err = os.WriteFile(sourceFile, []byte(`{"line-length": false}`), 0644)
+	assert.NilError(t, err)
+
+	oldHome := os.Getenv("HOME")
+	os.Setenv("HOME", tempDir)
+	defer os.Setenv("HOME", oldHome)
+
+	targetDir := filepath.Join(tempDir, "project")
+	err = os.MkdirAll(targetDir, 0755)
+	assert.NilError(t, err)
+
+	err = ApplyTemplate("markdownlint", targetDir, false)
+	assert.NilError(t, err)
+
+	destFile := filepath.Join(targetDir, ".markdownlint.json")
+	_, err = os.Stat(destFile)
+	assert.NilError(t, err, "destination file was not created")
+
+	content, err := os.ReadFile(destFile)
+	assert.NilError(t, err)
+
+	expected := `{"line-length": false}`
+	assert.Equal(t, string(content), expected)
+}
+
+func TestApplyTemplateWithForce(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "template_test")
+	assert.NilError(t, err)
+	defer os.RemoveAll(tempDir)
+
+	sourceDir := filepath.Join(tempDir, ".config", "ruff")
+	err = os.MkdirAll(sourceDir, 0755)
+	assert.NilError(t, err)
+
+	sourceFile := filepath.Join(sourceDir, "ruff.toml")
+	err = os.WriteFile(sourceFile, []byte(`line-length = 88`), 0644)
+	assert.NilError(t, err)
+
+	oldHome := os.Getenv("HOME")
+	os.Setenv("HOME", tempDir)
+	defer os.Setenv("HOME", oldHome)
+
+	targetDir := filepath.Join(tempDir, "project")
+	err = os.MkdirAll(targetDir, 0755)
+	assert.NilError(t, err)
+
+	destFile := filepath.Join(targetDir, ".ruff.toml")
+	err = os.WriteFile(destFile, []byte("existing content"), 0644)
+	assert.NilError(t, err)
+
+	err = ApplyTemplate("ruff", targetDir, false)
+	assert.ErrorContains(t, err, "file already exists")
+
+	err = ApplyTemplate("ruff", targetDir, true)
+	assert.NilError(t, err)
+
+	content, err := os.ReadFile(destFile)
+	assert.NilError(t, err)
+
+	expected := `line-length = 88`
+	assert.Equal(t, string(content), expected)
+}
+
+func TestShowTemplate(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "template_test")
+	assert.NilError(t, err)
+	defer os.RemoveAll(tempDir)
+
+	sourceDir := filepath.Join(tempDir, ".config", "yamllint")
+	err = os.MkdirAll(sourceDir, 0755)
+	assert.NilError(t, err)
+
+	sourceFile := filepath.Join(sourceDir, "config")
+	expectedContent := `extends: default
+rules:
+  line-length:
+    max: 120`
+	err = os.WriteFile(sourceFile, []byte(expectedContent), 0644)
+	assert.NilError(t, err)
+
+	oldHome := os.Getenv("HOME")
+	os.Setenv("HOME", tempDir)
+	defer os.Setenv("HOME", oldHome)
+
+	content, err := ShowTemplate("yamllint", false)
+	assert.NilError(t, err)
+
+	assert.Equal(t, content, expectedContent)
+}