diff --git a/examples/data-prep/extism/main.go b/examples/data-prep/extism/main.go
index f3ff005..3d3e8b1 100644
--- a/examples/data-prep/extism/main.go
+++ b/examples/data-prep/extism/main.go
@@ -43,7 +43,6 @@ func prepareRuntimeData(
 	// Add the request metadata to the context using the data.Provider
 	enrichedCtx, err := evaluator.AddDataToContext(ctx, requestMeta)
 	if err != nil {
-		logger.Error("Failed to prepare context with request data", "error", err)
 		return nil, fmt.Errorf("failed to prepare context: %w", err)
 	}
 
@@ -67,8 +66,7 @@ func evalAndExtractResult(
 	// Evaluate the script
 	response, err := evaluator.Eval(evalCtx)
 	if err != nil {
-		logger.Error("Failed to evaluate script", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("failed to evaluate script: %w", err)
 	}
 
 	// Process the result
@@ -81,7 +79,6 @@ func evalAndExtractResult(
 	// Return the result
 	resultMap, ok := val.(map[string]any)
 	if !ok {
-		logger.Error("Unexpected response type", "type", fmt.Sprintf("%T", val))
 		return nil, fmt.Errorf("unexpected response type: %T", val)
 	}
 
diff --git a/examples/data-prep/extism/main_test.go b/examples/data-prep/extism/main_test.go
index 15fa990..3166038 100644
--- a/examples/data-prep/extism/main_test.go
+++ b/examples/data-prep/extism/main_test.go
@@ -3,7 +3,6 @@ package main
 import (
 	"context"
 	"log/slog"
-	"os"
 	"testing"
 
 	"github.com/robbyt/go-polyscript"
@@ -31,12 +30,6 @@ func getTestStaticData() map[string]any {
 }
 
 func TestDemonstrateDataPrepAndEval(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
-	logger := slog.New(handler)
-
 	// Get static test data
 	staticData := getTestStaticData()
 
@@ -44,7 +37,7 @@ func TestDemonstrateDataPrepAndEval(t *testing.T) {
 	evaluator, err := polyscript.FromExtismBytesWithData(
 		wasmdata.TestModule,
 		staticData,
-		logger.Handler(),
+		slog.Default().Handler(),
 		wasmdata.EntrypointGreet,
 	)
 	if err != nil {
@@ -60,14 +53,9 @@ func TestDemonstrateDataPrepAndEval(t *testing.T) {
 }
 
 func TestPrepareRuntimeData(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
-	logger := slog.New(handler)
-
 	// Get static test data
 	staticData := getTestStaticData()
+	logger := slog.Default()
 
 	// Create evaluator using embedded WASM
 	evaluator, err := polyscript.FromExtismBytesWithData(
@@ -87,14 +75,9 @@ func TestPrepareRuntimeData(t *testing.T) {
 }
 
 func TestEvalAndExtractResult(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
-	logger := slog.New(handler)
-
 	// Get static test data
 	staticData := getTestStaticData()
+	logger := slog.Default()
 
 	// Create evaluator using embedded WASM
 	evaluator, err := polyscript.FromExtismBytesWithData(
@@ -118,12 +101,6 @@ func TestEvalAndExtractResult(t *testing.T) {
 }
 
 func TestFromExtismFileWithData(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
-	logger := slog.New(handler)
-
 	// Get static test data
 	staticData := getTestStaticData()
 
@@ -131,7 +108,7 @@ func TestFromExtismFileWithData(t *testing.T) {
 	evaluator, err := polyscript.FromExtismBytesWithData(
 		wasmdata.TestModule,
 		staticData,
-		logger.Handler(),
+		slog.Default().Handler(),
 		wasmdata.EntrypointGreet,
 	)
 	assert.NoError(t, err, "Should create evaluator without error")
diff --git a/examples/data-prep/risor/main.go b/examples/data-prep/risor/main.go
index 8767292..2e06d61 100644
--- a/examples/data-prep/risor/main.go
+++ b/examples/data-prep/risor/main.go
@@ -89,8 +89,7 @@ func evalAndExtractResult(
 	// Evaluate the script with the prepared context
 	result, err := evaluator.Eval(ctx)
 	if err != nil {
-		logger.Error("Script evaluation failed", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("script evaluation failed: %w", err)
 	}
 
 	// Process the result
@@ -102,7 +101,6 @@ func evalAndExtractResult(
 
 	data, ok := val.(map[string]any)
 	if !ok {
-		logger.Error("Result is not a map", "type", fmt.Sprintf("%T", val))
 		return nil, fmt.Errorf("result is not a map: %T", val)
 	}
 
diff --git a/examples/data-prep/risor/main_test.go b/examples/data-prep/risor/main_test.go
index 3fdcaae..a2dfac0 100644
--- a/examples/data-prep/risor/main_test.go
+++ b/examples/data-prep/risor/main_test.go
@@ -3,7 +3,6 @@ package main
 import (
 	"context"
 	"log/slog"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -11,15 +10,12 @@ import (
 )
 
 // Helper function to create Risor evaluator - makes testing easier
-func createRisorEvalHelper(t *testing.T, handler slog.Handler) (RisorEvaluator, error) {
+func createRisorEvalHelper(t *testing.T, logger *slog.Logger) (RisorEvaluator, error) {
 	t.Helper()
 
 	// Get static test data
 	staticData := getTestStaticData()
 
-	// Create a logger for testing
-	logger := slog.New(handler.WithGroup("risor-test"))
-
 	// Create evaluator with the script and static data
 	return createRisorEvaluator(logger, risorScript, staticData)
 }
@@ -47,26 +43,17 @@ func TestRun(t *testing.T) {
 }
 
 func TestCreateRisorEvaluator(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
-
 	// Test creating evaluator
-	evaluator, err := createRisorEvalHelper(t, handler)
+	evaluator, err := createRisorEvalHelper(t, slog.Default())
 	require.NoError(t, err, "Should create evaluator without error")
 	require.NotNil(t, evaluator, "Evaluator should not be nil")
 }
 
 func TestPrepareRuntimeData(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
-	logger := slog.New(handler)
+	logger := slog.Default()
 
 	// Create evaluator
-	evaluator, err := createRisorEvalHelper(t, handler)
+	evaluator, err := createRisorEvalHelper(t, logger)
 	require.NoError(t, err, "Failed to create evaluator")
 
 	// Test prepareRuntimeData function
@@ -77,14 +64,10 @@ func TestPrepareRuntimeData(t *testing.T) {
 }
 
 func TestEvalAndExtractResult(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
-	logger := slog.New(handler)
+	logger := slog.Default()
 
 	// Create evaluator
-	evaluator, err := createRisorEvalHelper(t, handler)
+	evaluator, err := createRisorEvalHelper(t, logger)
 	require.NoError(t, err, "Failed to create evaluator")
 
 	// Prepare data first
@@ -104,11 +87,7 @@ func TestEvalAndExtractResult(t *testing.T) {
 // TestFullExecution tests the entire execution flow as an integration test
 func TestFullExecution(t *testing.T) {
 	// This test mirrors the functionality in the run() function
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
-	logger := slog.New(handler)
+	logger := slog.Default()
 
 	// Get test static data
 	staticData := getTestStaticData()
diff --git a/examples/data-prep/starlark/main.go b/examples/data-prep/starlark/main.go
index 192724b..c721ca2 100644
--- a/examples/data-prep/starlark/main.go
+++ b/examples/data-prep/starlark/main.go
@@ -48,8 +48,7 @@ func prepareRuntimeData(
 	// Create an HTTP request object (will not make a real request!)
 	reqURL, err := url.Parse("http://localhost:8080/api/users?limit=10&offset=0")
 	if err != nil {
-		logger.Error("Failed to parse URL", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("failed to parse URL: %w", err)
 	}
 
 	httpReq := &http.Request{
@@ -103,8 +102,7 @@ func evalAndExtractResult(
 	// Evaluate the script with the prepared context
 	result, err := evaluator.Eval(ctx)
 	if err != nil {
-		logger.Error("Script evaluation failed", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("script evaluation failed: %w", err)
 	}
 
 	// Process the result
@@ -116,7 +114,6 @@ func evalAndExtractResult(
 
 	data, ok := val.(map[string]any)
 	if !ok {
-		logger.Error("Result is not a map", "type", fmt.Sprintf("%T", val))
 		return nil, fmt.Errorf("result is not a map: %T", val)
 	}
 
diff --git a/examples/data-prep/starlark/main_test.go b/examples/data-prep/starlark/main_test.go
index e461013..8bed1c7 100644
--- a/examples/data-prep/starlark/main_test.go
+++ b/examples/data-prep/starlark/main_test.go
@@ -3,7 +3,6 @@ package main
 import (
 	"context"
 	"log/slog"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -26,14 +25,6 @@ func getTestStaticData() map[string]any {
 	}
 }
 
-// setupTestLogger creates a logger for testing
-func setupTestLogger() *slog.Logger {
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
-	return slog.New(handler.WithGroup("starlark-test"))
-}
-
 func TestRun(t *testing.T) {
 	// This is a simple test of the run function
 	err := run()
@@ -41,7 +32,7 @@ func TestRun(t *testing.T) {
 }
 
 func TestCreateStarlarkEvaluator(t *testing.T) {
-	logger := setupTestLogger()
+	logger := slog.Default()
 	staticData := getTestStaticData()
 
 	// Test creating evaluator
@@ -56,7 +47,7 @@ func TestCreateStarlarkEvaluator(t *testing.T) {
 }
 
 func TestPrepareRuntimeData(t *testing.T) {
-	logger := setupTestLogger()
+	logger := slog.Default()
 	staticData := getTestStaticData()
 
 	// Create evaluator
@@ -71,7 +62,7 @@ func TestPrepareRuntimeData(t *testing.T) {
 }
 
 func TestEvalAndExtractResult(t *testing.T) {
-	logger := setupTestLogger()
+	logger := slog.Default()
 	staticData := getTestStaticData()
 
 	// Create evaluator
@@ -102,7 +93,7 @@ func TestEvalAndExtractResult(t *testing.T) {
 
 // TestFullExecution tests the entire execution flow as an integration test
 func TestFullExecution(t *testing.T) {
-	logger := setupTestLogger()
+	logger := slog.Default()
 	staticData := getTestStaticData()
 
 	// Create evaluator with static data
diff --git a/examples/multiple-instantiation/extism/main.go b/examples/multiple-instantiation/extism/main.go
index 1484c87..3a852e1 100644
--- a/examples/multiple-instantiation/extism/main.go
+++ b/examples/multiple-instantiation/extism/main.go
@@ -17,40 +17,33 @@ import (
 type ExtismEvaluator = platform.Evaluator
 
 // createEvaluator initializes an Extism evaluator with context provider for runtime data
-func createEvaluator(handler slog.Handler) (ExtismEvaluator, error) {
-	if handler == nil {
-		handler = slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-			Level: slog.LevelDebug,
-		})
+func createEvaluator(logger *slog.Logger) (ExtismEvaluator, error) {
+	if logger == nil {
+		logger = slog.Default()
 	}
-	logger := slog.New(handler.WithGroup("extism-evaluator"))
 
 	// Create the evaluator using embedded WASM
 	// Uses the simpler interface with dynamic data only via context
 	evaluator, err := polyscript.FromExtismBytes(
 		wasmdata.TestModule,
-		handler,
+		logger.Handler(),
 		wasmdata.EntrypointGreet,
 	)
 	if err != nil {
-		logger.Error("Failed to create evaluator", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("failed to create evaluator: %w", err)
 	}
 
 	return evaluator, nil
 }
 
 // runMultipleTimes demonstrates the "compile once, run many times" pattern with Extism
-func runMultipleTimes(handler slog.Handler) ([]map[string]any, error) {
-	if handler == nil {
-		handler = slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-			Level: slog.LevelDebug,
-		})
+func runMultipleTimes(logger *slog.Logger) ([]map[string]any, error) {
+	if logger == nil {
+		logger = slog.Default()
 	}
-	logger := slog.New(handler.WithGroup("extism-multiple"))
 
 	// Create the evaluator once
-	evaluator, err := createEvaluator(handler)
+	evaluator, err := createEvaluator(logger)
 	if err != nil {
 		return nil, err
 	}
@@ -77,8 +70,12 @@ func runMultipleTimes(handler slog.Handler) ([]map[string]any, error) {
 		cancel() // Cancel the context after execution
 
 		if err != nil {
-			logger.Error("Evaluation failed", "error", err, "execution", i+1)
-			return nil, err
+			return nil, fmt.Errorf(
+				"evaluation failed for input %q (execution %d): %w",
+				input,
+				i+1,
+				err,
+			)
 		}
 
 		// Process result
@@ -90,8 +87,7 @@ func runMultipleTimes(handler slog.Handler) ([]map[string]any, error) {
 
 		data, ok := val.(map[string]any)
 		if !ok {
-			logger.Error("Result is not a map", "type", fmt.Sprintf("%T", val), "execution", i+1)
-			return nil, fmt.Errorf("result is not a map: %T", val)
+			return nil, fmt.Errorf("result is not a map for execution %d: %T", i+1, val)
 		}
 
 		results = append(results, data)
@@ -109,10 +105,9 @@ func run() error {
 	logger := slog.New(handler.WithGroup("extism-example"))
 
 	// Run the example
-	results, err := runMultipleTimes(handler)
+	results, err := runMultipleTimes(logger)
 	if err != nil {
-		logger.Error("Failed to run example", "error", err)
-		return err
+		return fmt.Errorf("failed to run example: %w", err)
 	}
 
 	// Print the results
diff --git a/examples/multiple-instantiation/extism/main_test.go b/examples/multiple-instantiation/extism/main_test.go
index b150959..146001b 100644
--- a/examples/multiple-instantiation/extism/main_test.go
+++ b/examples/multiple-instantiation/extism/main_test.go
@@ -1,8 +1,6 @@
 package main
 
 import (
-	"log/slog"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -10,36 +8,31 @@ import (
 )
 
 func TestRunMultipleTimes(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
-
-	// Run the multiple execution example
-	results, err := runMultipleTimes(handler)
-	if err != nil {
-		t.Logf("Extism example failed: %v - this may be due to missing WASM file", err)
-		t.Skip("Skipping Extism test as it requires a WASM file")
-		return
-	}
-
-	// Verify we got 3 results
+	results, err := runMultipleTimes(nil)
+	require.NoError(t, err, "runMultipleTimes should not return an error")
+	require.NotNil(t, results, "Results should not be nil")
 	require.Len(t, results, 3, "Should have 3 results")
 
-	// Verify each result
-	expectedGreetings := []string{
+	expectedResults := []string{
 		"Hello, World!",
 		"Hello, Extism!",
 		"Hello, Go-PolyScript!",
 	}
 
 	for i, result := range results {
+		assert.NotNil(t, result, "Result at index %d should not be nil", i)
+
 		greeting, ok := result["greeting"]
-		assert.True(t, ok, "Result should have a greeting field")
-		assert.Equal(t, expectedGreetings[i], greeting, "Should have the correct greeting")
+		require.True(t, ok, "Result at index %d should have a greeting field", i)
+		assert.Equal(t, expectedResults[i], greeting,
+			"Result at index %d should have the correct greeting", i,
+		)
+
+		require.IsType(t, "", greeting, "Greeting at index %d should be a string", i)
 	}
 }
 
 func TestRun(t *testing.T) {
-	assert.NoError(t, run(), "run() should execute without error")
+	err := run()
+	require.NoError(t, err, "run() should execute without error")
 }
diff --git a/examples/multiple-instantiation/risor/main.go b/examples/multiple-instantiation/risor/main.go
index 4cdc880..2ee96b2 100644
--- a/examples/multiple-instantiation/risor/main.go
+++ b/examples/multiple-instantiation/risor/main.go
@@ -19,41 +19,38 @@ type RisorEvaluator = platform.Evaluator
 var risorScript string
 
 // createEvaluator initializes a Risor evaluator with context provider for runtime data
-func createEvaluator(handler slog.Handler) (RisorEvaluator, error) {
-	if handler == nil {
-		handler = slog.NewTextHandler(os.Stdout, nil)
+func createEvaluator(logger *slog.Logger) (RisorEvaluator, error) {
+	if logger == nil {
+		logger = slog.Default()
 	}
-	logger := slog.New(handler)
 
 	// Create evaluator using the new simplified interface
 	// This provides a dynamic context provider automatically
 	evaluator, err := polyscript.FromRisorString(
 		risorScript,
-		handler,
+		logger.Handler(),
 	)
 	if err != nil {
-		logger.Error("Failed to create evaluator", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("failed to create evaluator: %w", err)
 	}
 
 	return evaluator, nil
 }
 
 // runMultipleTimes demonstrates the "compile once, run many times" pattern
-func runMultipleTimes(handler slog.Handler) ([]map[string]any, error) {
-	if handler == nil {
-		handler = slog.NewTextHandler(os.Stdout, nil)
+func runMultipleTimes(logger *slog.Logger) ([]map[string]any, error) {
+	if logger == nil {
+		logger = slog.Default()
 	}
-	logger := slog.New(handler)
 
 	// Create the evaluator once
-	evaluator, err := createEvaluator(handler)
+	evaluator, err := createEvaluator(logger)
 	if err != nil {
 		return nil, err
 	}
 
 	// Names to greet - we'll run the script once for each name
-	names := []string{"World", "Risor", "Go"}
+	names := []string{"World", "Alice", "Bob", "Charlie"}
 	results := make([]map[string]any, 0, len(names))
 
 	// Execute the script multiple times with different inputs
@@ -72,8 +69,12 @@ func runMultipleTimes(handler slog.Handler) ([]map[string]any, error) {
 		// Execute the script with the context
 		result, err := evaluator.Eval(ctx)
 		if err != nil {
-			logger.Error("Script evaluation failed", "error", err, "execution", i+1)
-			return nil, err
+			return nil, fmt.Errorf(
+				"script evaluation failed for name %q (execution %d): %w",
+				name,
+				i+1,
+				err,
+			)
 		}
 
 		// Process result
@@ -85,8 +86,7 @@ func runMultipleTimes(handler slog.Handler) ([]map[string]any, error) {
 
 		data, ok := val.(map[string]any)
 		if !ok {
-			logger.Error("Result is not a map", "type", fmt.Sprintf("%T", val), "execution", i+1)
-			return nil, fmt.Errorf("result is not a map: %T", val)
+			return nil, fmt.Errorf("result is not a map for execution %d: %T", i+1, val)
 		}
 
 		results = append(results, data)
@@ -102,10 +102,9 @@ func run() error {
 	logger := slog.New(handler.WithGroup("risor-multiple-example"))
 
 	// Run the example
-	results, err := runMultipleTimes(handler)
+	results, err := runMultipleTimes(logger)
 	if err != nil {
-		logger.Error("Failed to run example", "error", err)
-		return err
+		return fmt.Errorf("failed to run example: %w", err)
 	}
 
 	// Print the results
diff --git a/examples/multiple-instantiation/risor/main_test.go b/examples/multiple-instantiation/risor/main_test.go
index 862013d..ce9f1a0 100644
--- a/examples/multiple-instantiation/risor/main_test.go
+++ b/examples/multiple-instantiation/risor/main_test.go
@@ -1,8 +1,6 @@
 package main
 
 import (
-	"log/slog"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -10,63 +8,57 @@ import (
 )
 
 func TestRunMultipleTimes(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
+	results, err := runMultipleTimes(nil)
+	require.NoError(t, err, "runMultipleTimes should not return an error")
+	require.NotNil(t, results, "Results should not be nil")
 
-	// Run the example
-	results, err := runMultipleTimes(handler)
-	require.NoError(t, err, "Risor example should run without error")
-
-	// Verify we got the expected number of results
-	require.Len(t, results, 3, "Should have 3 results")
-
-	// Expected greetings based on the inputs
-	expectedGreetings := []string{
-		"Hello, World!",
-		"Hello, Risor!",
-		"Hello, Go!",
-	}
-
-	// Expected lengths based on the greetings
-	expectedLengths := []int64{
-		13, // length of "Hello, World!"
-		13, // length of "Hello, Risor!"
-		10, // length of "Hello, Go!"
+	expectedResults := []struct {
+		name     string
+		greeting string
+		length   int64
+	}{
+		{
+			name:     "World",
+			greeting: "Hello, World!",
+			length:   13,
+		},
+		{
+			name:     "Alice",
+			greeting: "Hello, Alice!",
+			length:   13,
+		},
+		{
+			name:     "Bob",
+			greeting: "Hello, Bob!",
+			length:   11,
+		},
+		{
+			name:     "Charlie",
+			greeting: "Hello, Charlie!",
+			length:   15,
+		},
 	}
 
-	// Verify each result
-	for i, result := range results {
-		// Verify greeting
-		greeting, ok := result["greeting"].(string)
-		assert.True(t, ok, "Greeting should be a string")
-		assert.Equal(t, expectedGreetings[i], greeting, "Should have the correct greeting")
+	require.Len(t, results, len(expectedResults))
+	for i, expected := range expectedResults {
+		t.Run(expected.name, func(t *testing.T) {
+			result := results[i]
+			require.NotNil(t, result, "Result at index %d should not be nil", i)
 
-		// Verify length
-		length := result["length"]
-		assert.NotNil(t, length, "Should have a length field")
+			greeting, exists := result["greeting"]
+			require.True(t, exists, "Result should have a greeting field")
+			require.IsType(t, "", greeting, "Greeting should be a string")
+			assert.Equal(t, expected.greeting, greeting, "Should have the correct greeting")
 
-		// Check length based on its type (could be float64 or int64 depending on implementation)
-		lengthValue, ok := length.(int64)
-		if !ok {
-			lengthValueFloat, ok := length.(float64)
-			if ok {
-				assert.Equal(
-					t,
-					float64(expectedLengths[i]),
-					lengthValueFloat,
-					"Should have the correct length",
-				)
-			} else {
-				assert.Fail(t, "Length is neither int64 nor float64")
-			}
-		} else {
-			assert.Equal(t, expectedLengths[i], lengthValue, "Should have the correct length")
-		}
+			length, exists := result["length"]
+			require.True(t, exists, "Result should have a length field")
+			require.IsType(t, int64(0), length, "Length should be int64")
+			assert.Equal(t, expected.length, length, "Should have the correct length")
+		})
 	}
 }
 
 func TestRun(t *testing.T) {
-	assert.NoError(t, run(), "run() should execute without error")
+	err := run()
+	require.NoError(t, err, "run() should execute without error")
 }
diff --git a/examples/multiple-instantiation/starlark/main.go b/examples/multiple-instantiation/starlark/main.go
index 33c561e..12c78cf 100644
--- a/examples/multiple-instantiation/starlark/main.go
+++ b/examples/multiple-instantiation/starlark/main.go
@@ -19,35 +19,32 @@ type StarlarkEvaluator = platform.Evaluator
 var starlarkScript string
 
 // createEvaluator initializes a Starlark evaluator with context provider for runtime data
-func createEvaluator(handler slog.Handler) (StarlarkEvaluator, error) {
-	if handler == nil {
-		handler = slog.NewTextHandler(os.Stdout, nil)
+func createEvaluator(logger *slog.Logger) (StarlarkEvaluator, error) {
+	if logger == nil {
+		logger = slog.Default()
 	}
-	logger := slog.New(handler)
 
 	// Create evaluator using the new simplified interface
 	// This provides a dynamic context provider automatically
 	evaluator, err := polyscript.FromStarlarkString(
 		starlarkScript,
-		handler,
+		logger.Handler(),
 	)
 	if err != nil {
-		logger.Error("Failed to create evaluator", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("failed to create evaluator: %w", err)
 	}
 
 	return evaluator, nil
 }
 
 // runMultipleTimes demonstrates the "compile once, run many times" pattern
-func runMultipleTimes(handler slog.Handler) ([]map[string]any, error) {
-	if handler == nil {
-		handler = slog.NewTextHandler(os.Stdout, nil)
+func runMultipleTimes(logger *slog.Logger) ([]map[string]any, error) {
+	if logger == nil {
+		logger = slog.Default()
 	}
-	logger := slog.New(handler)
 
 	// Create the evaluator once
-	evaluator, err := createEvaluator(handler)
+	evaluator, err := createEvaluator(logger)
 	if err != nil {
 		return nil, err
 	}
@@ -72,8 +69,7 @@ func runMultipleTimes(handler slog.Handler) ([]map[string]any, error) {
 		// Execute the script with the context
 		result, err := evaluator.Eval(ctx)
 		if err != nil {
-			logger.Error("Script evaluation failed", "error", err, "name", name)
-			continue
+			return nil, fmt.Errorf("script evaluation failed for name %q: %w", name, err)
 		}
 
 		// Process result
@@ -85,8 +81,7 @@ func runMultipleTimes(handler slog.Handler) ([]map[string]any, error) {
 
 		data, ok := val.(map[string]any)
 		if !ok {
-			logger.Error("Result is not a map", "type", fmt.Sprintf("%T", val), "name", name)
-			continue
+			return nil, fmt.Errorf("result is not a map for name %q: %T", name, val)
 		}
 
 		results = append(results, data)
@@ -102,10 +97,9 @@ func run() error {
 	logger := slog.New(handler.WithGroup("starlark-multiple-example"))
 
 	// Run the example
-	results, err := runMultipleTimes(handler)
+	results, err := runMultipleTimes(logger)
 	if err != nil {
-		logger.Error("Failed to run example", "error", err)
-		return err
+		return fmt.Errorf("failed to run example: %w", err)
 	}
 
 	// Print the results
diff --git a/examples/multiple-instantiation/starlark/main_test.go b/examples/multiple-instantiation/starlark/main_test.go
index 5a8c7d0..267fa9d 100644
--- a/examples/multiple-instantiation/starlark/main_test.go
+++ b/examples/multiple-instantiation/starlark/main_test.go
@@ -1,8 +1,6 @@
 package main
 
 import (
-	"log/slog"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -10,61 +8,58 @@ import (
 )
 
 func TestRunMultipleTimes(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
+	results, err := runMultipleTimes(nil)
+	require.NoError(t, err, "runMultipleTimes should not return an error")
+	require.NotNil(t, results, "Results should not be nil")
 
-	// Run the "compile once, run many times" example
-	results, err := runMultipleTimes(handler)
-	require.NoError(t, err, "Multiple executions should run without error")
-
-	// Expect 4 results (World, Alice, Bob, Charlie)
-	require.Len(t, results, 4, "Should have 4 results from multiple executions")
-
-	// Check each result
-	expectedNames := []string{"World", "Alice", "Bob", "Charlie"}
-	for i, name := range expectedNames {
-		result := results[i]
-		expectedGreeting := "Hello, " + name + "!"
+	expectedResults := []struct {
+		name     string
+		greeting string
+		length   int64
+	}{
+		{
+			name:     "World",
+			greeting: "Hello, World!",
+			length:   13,
+		},
+		{
+			name:     "Alice",
+			greeting: "Hello, Alice!",
+			length:   13,
+		},
+		{
+			name:     "Bob",
+			greeting: "Hello, Bob!",
+			length:   11,
+		},
+		{
+			name:     "Charlie",
+			greeting: "Hello, Charlie!",
+			length:   15,
+		},
+	}
 
-		// Verify greeting
-		assert.Equal(
-			t,
-			expectedGreeting,
-			result["greeting"],
-			"Should have the correct greeting for %s",
-			name,
-		)
+	require.Len(t, results, len(expectedResults), "Should have %d results", len(expectedResults))
 
-		// Verify length
-		length := result["length"]
-		assert.NotNil(t, length, "Should have a length field")
+	for i, expected := range expectedResults {
+		t.Run(expected.name, func(t *testing.T) {
+			result := results[i]
+			require.NotNil(t, result, "Result at index %d should not be nil", i)
 
-		// Length should match the greeting length
-		expectedLength := int64(len(expectedGreeting))
+			greeting, exists := result["greeting"]
+			require.True(t, exists, "Result should have a greeting field")
+			require.IsType(t, "", greeting, "Greeting should be a string")
+			assert.Equal(t, expected.greeting, greeting, "Should have the correct greeting")
 
-		// Handle different numeric types
-		lengthValue, ok := length.(int64)
-		if !ok {
-			lengthValueFloat, ok := length.(float64)
-			if ok {
-				assert.Equal(
-					t,
-					float64(expectedLength),
-					lengthValueFloat,
-					"Should have the correct length for %s",
-					name,
-				)
-			} else {
-				assert.Fail(t, "Length is neither int64 nor float64")
-			}
-		} else {
-			assert.Equal(t, expectedLength, lengthValue, "Should have the correct length for %s", name)
-		}
+			length, exists := result["length"]
+			require.True(t, exists, "Result should have a length field")
+			require.IsType(t, int64(0), length, "Length should be int64")
+			assert.Equal(t, expected.length, length, "Should have the correct length")
+		})
 	}
 }
 
 func TestRun(t *testing.T) {
-	assert.NoError(t, run(), "run() should execute without error")
+	err := run()
+	require.NoError(t, err, "run() should execute without error")
 }
diff --git a/examples/simple/extism/main.go b/examples/simple/extism/main.go
index c7dfd51..5a5e9f9 100644
--- a/examples/simple/extism/main.go
+++ b/examples/simple/extism/main.go
@@ -12,13 +12,10 @@ import (
 )
 
 // runExtismExample executes an Extism WASM module and returns the result
-func runExtismExample(handler slog.Handler) (map[string]any, error) {
-	if handler == nil {
-		handler = slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-			Level: slog.LevelDebug,
-		})
+func runExtismExample(logger *slog.Logger) (map[string]any, error) {
+	if logger == nil {
+		logger = slog.Default()
 	}
-	logger := slog.New(handler)
 
 	// Create input data
 	inputData := map[string]any{
@@ -29,12 +26,11 @@ func runExtismExample(handler slog.Handler) (map[string]any, error) {
 	evaluator, err := polyscript.FromExtismBytesWithData(
 		wasmdata.TestModule,
 		inputData,
-		handler,
+		logger.Handler(),
 		wasmdata.EntrypointGreet,
 	)
 	if err != nil {
-		logger.Error("Failed to create evaluator", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("failed to create evaluator: %w", err)
 	}
 
 	// Set a timeout for script execution
@@ -44,8 +40,7 @@ func runExtismExample(handler slog.Handler) (map[string]any, error) {
 	// Evaluate the script
 	response, err := evaluator.Eval(ctx)
 	if err != nil {
-		logger.Error("Failed to evaluate script", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("failed to evaluate script: %w", err)
 	}
 
 	// Process the result
@@ -71,7 +66,7 @@ func run() error {
 	logger := slog.New(handler.WithGroup("extism-simple-example"))
 
 	// Run the example
-	result, err := runExtismExample(handler)
+	result, err := runExtismExample(logger)
 	if err != nil {
 		return fmt.Errorf("failed to run example: %w", err)
 	}
diff --git a/examples/simple/extism/main_test.go b/examples/simple/extism/main_test.go
index bfec0ba..e0b6ebe 100644
--- a/examples/simple/extism/main_test.go
+++ b/examples/simple/extism/main_test.go
@@ -1,8 +1,6 @@
 package main
 
 import (
-	"log/slog"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -10,20 +8,17 @@ import (
 )
 
 func TestRunExtismExample(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
+	result, err := runExtismExample(nil)
+	require.NoError(t, err, "runExtismExample should not return an error")
+	require.NotNil(t, result, "Result should not be nil")
 
-	// Run the example
-	result, err := runExtismExample(handler)
-	require.NoError(t, err, "Extism example should run without error")
-
-	// Verify the result
-	assert.NotEmpty(t, result, "Result should not be empty")
-	assert.Contains(t, result, "greeting", "Result should contain a greeting field")
+	greeting, exists := result["greeting"]
+	require.True(t, exists, "Result should have a greeting field")
+	require.IsType(t, "", greeting, "Greeting should be a string")
+	assert.Equal(t, "Hello, World!", greeting, "Should have the correct greeting")
 }
 
 func TestRun(t *testing.T) {
-	assert.NoError(t, run(), "run() should execute without errors")
+	err := run()
+	require.NoError(t, err, "run() should execute without error")
 }
diff --git a/examples/simple/risor/main.go b/examples/simple/risor/main.go
index 3f35b41..0597daa 100644
--- a/examples/simple/risor/main.go
+++ b/examples/simple/risor/main.go
@@ -14,11 +14,10 @@ import (
 var risorScript string
 
 // runRisorExample executes a Risor script once and returns the result
-func runRisorExample(handler slog.Handler) (map[string]any, error) {
-	if handler == nil {
-		handler = slog.NewTextHandler(os.Stdout, nil)
+func runRisorExample(logger *slog.Logger) (map[string]any, error) {
+	if logger == nil {
+		logger = slog.Default()
 	}
-	logger := slog.New(handler)
 
 	// Create input data
 	input := map[string]any{
@@ -30,29 +29,21 @@ func runRisorExample(handler slog.Handler) (map[string]any, error) {
 	evaluator, err := polyscript.FromRisorStringWithData(
 		risorScript,
 		input,
-		handler,
+		logger.Handler(),
 	)
 	if err != nil {
-		logger.Error("Failed to create evaluator", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("failed to create evaluator: %w", err)
 	}
 
 	// Execute the script
-	ctx := context.Background()
 	if evaluator == nil {
 		logger.Error("Evaluator is nil")
 		return nil, fmt.Errorf("evaluator is nil")
 	}
+	ctx := context.Background()
 	result, err := evaluator.Eval(ctx)
 	if err != nil {
-		logger.Error(
-			"Script evaluation failed",
-			"error",
-			err,
-			"evaluator",
-			fmt.Sprintf("%T", evaluator),
-		)
-		return nil, err
+		return nil, fmt.Errorf("failed to evaluate script: %w", err)
 	}
 
 	// Handle potential nil result from Interface()
@@ -68,7 +59,6 @@ func runRisorExample(handler slog.Handler) (map[string]any, error) {
 	// Otherwise return the actual result
 	data, ok := val.(map[string]any)
 	if !ok {
-		logger.Error("Result is not a map", "type", fmt.Sprintf("%T", val))
 		return nil, fmt.Errorf("result is not a map: %T", val)
 	}
 	return data, nil
@@ -80,7 +70,7 @@ func run() error {
 	logger := slog.New(handler.WithGroup("risor-simple-example"))
 
 	// Run the example
-	result, err := runRisorExample(handler)
+	result, err := runRisorExample(logger)
 	if err != nil {
 		return fmt.Errorf("failed to run example: %w", err)
 	}
diff --git a/examples/simple/risor/main_test.go b/examples/simple/risor/main_test.go
index ff447db..775750e 100644
--- a/examples/simple/risor/main_test.go
+++ b/examples/simple/risor/main_test.go
@@ -1,8 +1,6 @@
 package main
 
 import (
-	"log/slog"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -10,34 +8,22 @@ import (
 )
 
 func TestRunRisorExample(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
+	result, err := runRisorExample(nil)
+	require.NoError(t, err, "runRisorExample should not return an error")
+	require.NotNil(t, result, "Result should not be nil")
 
-	// Run the example
-	result, err := runRisorExample(handler)
-	require.NoError(t, err, "Risor example should run without error")
+	greeting, exists := result["greeting"]
+	require.True(t, exists, "Result should have a greeting field")
+	require.IsType(t, "", greeting, "Greeting should be a string")
+	assert.Equal(t, "Hello, World!", greeting, "Should have the correct greeting")
 
-	// Verify the result
-	assert.Equal(t, "Hello, World!", result["greeting"], "Should have the correct greeting")
-
-	// Check length based on its type (could be float64 or int64 depending on implementation)
-	length := result["length"]
-	assert.NotNil(t, length, "Should have a length field")
-	lengthValue, ok := length.(int64)
-	if !ok {
-		lengthValueFloat, ok := length.(float64)
-		if ok {
-			assert.Equal(t, float64(13), lengthValueFloat, "Should have the correct length")
-		} else {
-			assert.Fail(t, "Length is neither int64 nor float64")
-		}
-	} else {
-		assert.Equal(t, int64(13), lengthValue, "Should have the correct length")
-	}
+	length, exists := result["length"]
+	require.True(t, exists, "Result should have a length field")
+	require.IsType(t, int64(0), length, "Length should be int64")
+	assert.Equal(t, int64(13), length, "Should have the correct length")
 }
 
 func TestRun(t *testing.T) {
-	assert.NoError(t, run(), "run() should execute without errors")
+	err := run()
+	require.NoError(t, err, "run() should execute without error")
 }
diff --git a/examples/simple/starlark/main.go b/examples/simple/starlark/main.go
index e313713..f238836 100644
--- a/examples/simple/starlark/main.go
+++ b/examples/simple/starlark/main.go
@@ -14,11 +14,10 @@ import (
 var starlarkScript string
 
 // runStarlarkExample executes a Starlark script once and returns the result
-func runStarlarkExample(handler slog.Handler) (map[string]any, error) {
-	if handler == nil {
-		handler = slog.NewTextHandler(os.Stdout, nil)
+func runStarlarkExample(logger *slog.Logger) (map[string]any, error) {
+	if logger == nil {
+		logger = slog.Default()
 	}
-	logger := slog.New(handler)
 
 	// Create input data
 	input := map[string]any{
@@ -29,19 +28,17 @@ func runStarlarkExample(handler slog.Handler) (map[string]any, error) {
 	evaluator, err := polyscript.FromStarlarkStringWithData(
 		starlarkScript,
 		input,
-		handler,
+		logger.Handler(),
 	)
 	if err != nil {
-		logger.Error("Failed to create evaluator", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("failed to create evaluator: %w", err)
 	}
 
 	// Execute the script
 	ctx := context.Background()
 	result, err := evaluator.Eval(ctx)
 	if err != nil {
-		logger.Error("Failed to evaluate script", "error", err)
-		return nil, err
+		return nil, fmt.Errorf("failed to evaluate script: %w", err)
 	}
 
 	// Handle potential nil result from Interface()
@@ -54,7 +51,6 @@ func runStarlarkExample(handler slog.Handler) (map[string]any, error) {
 	// Process the result
 	data, ok := val.(map[string]any)
 	if !ok {
-		logger.Error("Result is not a map", "type", fmt.Sprintf("%T", val))
 		return nil, fmt.Errorf("result is not a map: %T", val)
 	}
 	return data, nil
@@ -66,7 +62,7 @@ func run() error {
 	logger := slog.New(handler.WithGroup("starlark-simple-example"))
 
 	// Run the example
-	result, err := runStarlarkExample(handler)
+	result, err := runStarlarkExample(logger)
 	if err != nil {
 		return fmt.Errorf("failed to run example: %w", err)
 	}
diff --git a/examples/simple/starlark/main_test.go b/examples/simple/starlark/main_test.go
index 8583164..5827bd1 100644
--- a/examples/simple/starlark/main_test.go
+++ b/examples/simple/starlark/main_test.go
@@ -1,8 +1,6 @@
 package main
 
 import (
-	"log/slog"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -10,20 +8,22 @@ import (
 )
 
 func TestRunStarlarkExample(t *testing.T) {
-	// Create a test logger
-	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})
+	result, err := runStarlarkExample(nil)
+	require.NoError(t, err, "runStarlarkExample should not return an error")
+	require.NotNil(t, result, "Result should not be nil")
 
-	// Run the example
-	result, err := runStarlarkExample(handler)
-	require.NoError(t, err, "Starlark example should run without error")
+	greeting, exists := result["greeting"]
+	require.True(t, exists, "Result should have a greeting field")
+	require.IsType(t, "", greeting, "Greeting should be a string")
+	assert.Equal(t, "Hello, World!", greeting, "Should have the correct greeting")
 
-	// Verify the result
-	assert.Equal(t, "Hello, World!", result["greeting"], "Should have the correct greeting")
-	assert.Equal(t, int64(13), result["length"], "Should have the correct length")
+	length, exists := result["length"]
+	require.True(t, exists, "Result should have a length field")
+	require.IsType(t, int64(0), length, "Length should be int64")
+	assert.Equal(t, int64(13), length, "Should have the correct length")
 }
 
 func TestRun(t *testing.T) {
-	assert.NoError(t, run(), "run() should execute without errors")
+	err := run()
+	require.NoError(t, err, "run() should execute without error")
 }