diff --git a/slog/benchmarks/benchmarks_test.go b/slog/benchmarks/benchmarks_test.go
index a12b2e9..0611257 100644
--- a/slog/benchmarks/benchmarks_test.go
+++ b/slog/benchmarks/benchmarks_test.go
@@ -41,7 +41,7 @@
 					// should only be from Duration.String and Time.String.
 					"5 args",
 					func() {
-						logger.LogAttrs(slog.InfoLevel, TestMessage,
+						logger.LogAttrs(slog.LevelInfo, TestMessage,
 							slog.String("string", TestString),
 							slog.Int("status", TestInt),
 							slog.Duration("duration", TestDuration),
@@ -53,7 +53,7 @@
 				{
 					"5 args ctx",
 					func() {
-						logger.WithContext(ctx).LogAttrs(slog.InfoLevel, TestMessage,
+						logger.WithContext(ctx).LogAttrs(slog.LevelInfo, TestMessage,
 							slog.String("string", TestString),
 							slog.Int("status", TestInt),
 							slog.Duration("duration", TestDuration),
@@ -65,7 +65,7 @@
 				{
 					"10 args",
 					func() {
-						logger.LogAttrs(slog.InfoLevel, TestMessage,
+						logger.LogAttrs(slog.LevelInfo, TestMessage,
 							slog.String("string", TestString),
 							slog.Int("status", TestInt),
 							slog.Duration("duration", TestDuration),
@@ -82,7 +82,7 @@
 				{
 					"40 args",
 					func() {
-						logger.LogAttrs(slog.InfoLevel, TestMessage,
+						logger.LogAttrs(slog.LevelInfo, TestMessage,
 							slog.String("string", TestString),
 							slog.Int("status", TestInt),
 							slog.Duration("duration", TestDuration),
diff --git a/slog/benchmarks/handlers_test.go b/slog/benchmarks/handlers_test.go
index a16c6a7..b1e906d 100644
--- a/slog/benchmarks/handlers_test.go
+++ b/slog/benchmarks/handlers_test.go
@@ -9,7 +9,7 @@
 )
 
 func TestHandlers(t *testing.T) {
-	r := slog.NewRecord(TestTime, slog.InfoLevel, TestMessage, 0, nil)
+	r := slog.NewRecord(TestTime, slog.LevelInfo, TestMessage, 0, nil)
 	r.AddAttrs(TestAttrs...)
 	t.Run("text", func(t *testing.T) {
 		var b bytes.Buffer
diff --git a/slog/doc.go b/slog/doc.go
index 09c601e..ed32e0c 100644
--- a/slog/doc.go
+++ b/slog/doc.go
@@ -102,7 +102,7 @@
 
 The call
 
-    logger.LogAttrs(slog.InfoLevel, "hello", slog.Int("count", 3))
+    logger.LogAttrs(slog.LevelInfo, "hello", slog.Int("count", 3))
 
 is the most efficient way to achieve the same output as
 
@@ -140,7 +140,7 @@
 
 Now the program can change its logging level with a single statement:
 
-    programLevel.Set(slog.DebugLevel)
+    programLevel.Set(slog.LevelDebug)
 
 
 # Configuring the built-in handlers
diff --git a/slog/example_level_handler_test.go b/slog/example_level_handler_test.go
index b66a812..5374447 100644
--- a/slog/example_level_handler_test.go
+++ b/slog/example_level_handler_test.go
@@ -64,7 +64,7 @@
 		},
 	}.NewTextHandler(os.Stdout)
 
-	logger := slog.New(NewLevelHandler(slog.WarnLevel, th))
+	logger := slog.New(NewLevelHandler(slog.LevelWarn, th))
 	logger.Info("not printed")
 	logger.Warn("printed")
 
diff --git a/slog/handler.go b/slog/handler.go
index 778c932..7fcf1da 100644
--- a/slog/handler.go
+++ b/slog/handler.go
@@ -77,7 +77,7 @@
 }
 
 func (*defaultHandler) Enabled(l Level) bool {
-	return l >= InfoLevel
+	return l >= LevelInfo
 }
 
 // Collect the level, attributes and message in a string and
@@ -116,7 +116,7 @@
 
 	// Level reports the minimum record level that will be logged.
 	// The handler discards records with lower levels.
-	// If Level is nil, the handler assumes InfoLevel.
+	// If Level is nil, the handler assumes LevelInfo.
 	// The handler calls Level.Level for each record processed;
 	// to adjust the minimum level dynamically, use a LevelVar.
 	Level Leveler
@@ -195,7 +195,7 @@
 // Enabled reports whether l is greater than or equal to the
 // minimum level.
 func (h *commonHandler) enabled(l Level) bool {
-	minLevel := InfoLevel
+	minLevel := LevelInfo
 	if h.opts.Level != nil {
 		minLevel = h.opts.Level.Level()
 	}
diff --git a/slog/handler_test.go b/slog/handler_test.go
index be4a925..a9c73ac 100644
--- a/slog/handler_test.go
+++ b/slog/handler_test.go
@@ -91,7 +91,7 @@
 			if test.with != nil {
 				h = test.with(h)
 			}
-			r := NewRecord(time.Time{}, InfoLevel, "message", 0, nil)
+			r := NewRecord(time.Time{}, LevelInfo, "message", 0, nil)
 			r.AddAttrs(test.attrs...)
 			if err := h.Handle(r); err != nil {
 				t.Fatal(err)
@@ -283,7 +283,7 @@
 			wantJSON: `{"msg":"message","bs":1234}`,
 		},
 	} {
-		r := NewRecord(testTime, InfoLevel, "message", 1, nil)
+		r := NewRecord(testTime, LevelInfo, "message", 1, nil)
 		r.AddAttrs(test.attrs...)
 		var buf bytes.Buffer
 		opts := HandlerOptions{ReplaceAttr: test.replace}
@@ -355,14 +355,14 @@
 		want    bool
 	}{
 		{nil, true},
-		{WarnLevel, false},
+		{LevelWarn, false},
 		{&LevelVar{}, true}, // defaults to Info
-		{levelVar(WarnLevel), false},
-		{DebugLevel, true},
-		{levelVar(DebugLevel), true},
+		{levelVar(LevelWarn), false},
+		{LevelDebug, true},
+		{levelVar(LevelDebug), true},
 	} {
 		h := &commonHandler{opts: HandlerOptions{Level: test.leveler}}
-		got := h.enabled(InfoLevel)
+		got := h.enabled(LevelInfo)
 		if got != test.want {
 			t.Errorf("%v: got %t, want %t", test.leveler, got, test.want)
 		}
diff --git a/slog/json_handler_test.go b/slog/json_handler_test.go
index ef3be9b..635d534 100644
--- a/slog/json_handler_test.go
+++ b/slog/json_handler_test.go
@@ -39,7 +39,7 @@
 		t.Run(test.name, func(t *testing.T) {
 			var buf bytes.Buffer
 			h := test.opts.NewJSONHandler(&buf)
-			r := NewRecord(testTime, InfoLevel, "m", 0, nil)
+			r := NewRecord(testTime, LevelInfo, "m", 0, nil)
 			r.AddAttrs(Int("a", 1), Any("m", map[string]int{"b": 2}))
 			if err := h.Handle(r); err != nil {
 				t.Fatal(err)
@@ -103,7 +103,7 @@
 		{math.NaN(), `"NaN"`},
 		{math.Inf(+1), `"+Inf"`},
 		{math.Inf(-1), `"-Inf"`},
-		{WarnLevel, `"WARN"`},
+		{LevelWarn, `"WARN"`},
 	} {
 		got := jsonValueString(t, AnyValue(test.value))
 		if got != test.want {
@@ -162,7 +162,7 @@
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
-				l.LogAttrs(InfoLevel, "this is a typical log message",
+				l.LogAttrs(LevelInfo, "this is a typical log message",
 					String("module", "github.com/google/go-cmp"),
 					String("version", "v1.23.4"),
 					Int("count", 23),
@@ -223,7 +223,7 @@
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
-				l.LogAttrs(InfoLevel, "this is a typical log message",
+				l.LogAttrs(LevelInfo, "this is a typical log message",
 					String("module", "github.com/google/go-cmp"),
 					String("version", "v1.23.4"),
 					Int("count", 23),
diff --git a/slog/level.go b/slog/level.go
index c613cf9..f6588de 100644
--- a/slog/level.go
+++ b/slog/level.go
@@ -40,10 +40,10 @@
 //
 // Names for common levels.
 const (
-	DebugLevel Level = -4
-	InfoLevel  Level = 0
-	WarnLevel  Level = 4
-	ErrorLevel Level = 8
+	LevelDebug Level = -4
+	LevelInfo  Level = 0
+	LevelWarn  Level = 4
+	LevelError Level = 8
 )
 
 // String returns a name for the level.
@@ -53,8 +53,8 @@
 // an integer is appended to the uppercased name.
 // Examples:
 //
-//	WarnLevel.String() => "WARN"
-//	(WarnLevel-2).String() => "WARN-2"
+//	LevelWarn.String() => "WARN"
+//	(LevelWarn-2).String() => "WARN-2"
 func (l Level) String() string {
 	str := func(base string, val Level) string {
 		if val == 0 {
@@ -64,14 +64,14 @@
 	}
 
 	switch {
-	case l < InfoLevel:
-		return str("DEBUG", l-DebugLevel)
-	case l < WarnLevel:
-		return str("INFO", l-InfoLevel)
-	case l < ErrorLevel:
-		return str("WARN", l-WarnLevel)
+	case l < LevelInfo:
+		return str("DEBUG", l-LevelDebug)
+	case l < LevelWarn:
+		return str("INFO", l-LevelInfo)
+	case l < LevelError:
+		return str("WARN", l-LevelWarn)
 	default:
-		return str("ERROR", l-ErrorLevel)
+		return str("ERROR", l-LevelError)
 	}
 }
 
@@ -90,7 +90,7 @@
 // dynamically.
 // It implements Leveler as well as a Set method,
 // and it is safe for use by multiple goroutines.
-// The zero LevelVar corresponds to InfoLevel.
+// The zero LevelVar corresponds to LevelInfo.
 type LevelVar struct {
 	val atomic.Int64
 }
diff --git a/slog/level_test.go b/slog/level_test.go
index d85de39..833ef3e 100644
--- a/slog/level_test.go
+++ b/slog/level_test.go
@@ -14,16 +14,16 @@
 		want string
 	}{
 		{0, "INFO"},
-		{ErrorLevel, "ERROR"},
-		{ErrorLevel + 2, "ERROR+2"},
-		{ErrorLevel - 2, "WARN+2"},
-		{WarnLevel, "WARN"},
-		{WarnLevel - 1, "INFO+3"},
-		{InfoLevel, "INFO"},
-		{InfoLevel + 1, "INFO+1"},
-		{InfoLevel - 3, "DEBUG+1"},
-		{DebugLevel, "DEBUG"},
-		{DebugLevel - 2, "DEBUG-2"},
+		{LevelError, "ERROR"},
+		{LevelError + 2, "ERROR+2"},
+		{LevelError - 2, "WARN+2"},
+		{LevelWarn, "WARN"},
+		{LevelWarn - 1, "INFO+3"},
+		{LevelInfo, "INFO"},
+		{LevelInfo + 1, "INFO+1"},
+		{LevelInfo - 3, "DEBUG+1"},
+		{LevelDebug, "DEBUG"},
+		{LevelDebug - 2, "DEBUG-2"},
 	} {
 		got := test.in.String()
 		if got != test.want {
@@ -34,15 +34,15 @@
 
 func TestLevelVar(t *testing.T) {
 	var al LevelVar
-	if got, want := al.Level(), InfoLevel; got != want {
+	if got, want := al.Level(), LevelInfo; got != want {
 		t.Errorf("got %v, want %v", got, want)
 	}
-	al.Set(WarnLevel)
-	if got, want := al.Level(), WarnLevel; got != want {
+	al.Set(LevelWarn)
+	if got, want := al.Level(), LevelWarn; got != want {
 		t.Errorf("got %v, want %v", got, want)
 	}
-	al.Set(InfoLevel)
-	if got, want := al.Level(), InfoLevel; got != want {
+	al.Set(LevelInfo)
+	if got, want := al.Level(), LevelInfo; got != want {
 		t.Errorf("got %v, want %v", got, want)
 	}
 
diff --git a/slog/logger.go b/slog/logger.go
index cffc23c..3707a10 100644
--- a/slog/logger.go
+++ b/slog/logger.go
@@ -22,7 +22,7 @@
 
 // SetDefault makes l the default Logger.
 // After this call, output from the log package's default Logger
-// (as with [log.Print], etc.) will be logged at InfoLevel using l's Handler.
+// (as with [log.Print], etc.) will be logged at LevelInfo using l's Handler.
 func SetDefault(l *Logger) {
 	defaultLogger.Store(l)
 	// If the default's handler is a defaultHandler, then don't use a handleWriter,
@@ -54,7 +54,7 @@
 	if len(buf) > 0 && buf[len(buf)-1] == '\n' {
 		buf = buf[:len(buf)-1]
 	}
-	r := NewRecord(time.Now(), InfoLevel, string(buf), depth, nil)
+	r := NewRecord(time.Now(), LevelInfo, string(buf), depth, nil)
 	return origLen, w.h.Handle(r)
 }
 
@@ -186,46 +186,46 @@
 	_ = l.Handler().Handle(r)
 }
 
-// Debug logs at DebugLevel.
+// Debug logs at LevelDebug.
 func (l *Logger) Debug(msg string, args ...any) {
-	l.LogDepth(0, DebugLevel, msg, args...)
+	l.LogDepth(0, LevelDebug, msg, args...)
 }
 
-// Info logs at InfoLevel.
+// Info logs at LevelInfo.
 func (l *Logger) Info(msg string, args ...any) {
-	l.LogDepth(0, InfoLevel, msg, args...)
+	l.LogDepth(0, LevelInfo, msg, args...)
 }
 
-// Warn logs at WarnLevel.
+// Warn logs at LevelWarn.
 func (l *Logger) Warn(msg string, args ...any) {
-	l.LogDepth(0, WarnLevel, msg, args...)
+	l.LogDepth(0, LevelWarn, msg, args...)
 }
 
-// Error logs at ErrorLevel.
+// Error logs at LevelError.
 // If err is non-nil, Error appends Any(ErrorKey, err)
 // to the list of attributes.
 func (l *Logger) Error(msg string, err error, args ...any) {
-	l.logDepthErr(err, 0, ErrorLevel, msg, args...)
+	l.logDepthErr(err, 0, LevelError, msg, args...)
 }
 
 // Debug calls Logger.Debug on the default logger.
 func Debug(msg string, args ...any) {
-	Default().LogDepth(0, DebugLevel, msg, args...)
+	Default().LogDepth(0, LevelDebug, msg, args...)
 }
 
 // Info calls Logger.Info on the default logger.
 func Info(msg string, args ...any) {
-	Default().LogDepth(0, InfoLevel, msg, args...)
+	Default().LogDepth(0, LevelInfo, msg, args...)
 }
 
 // Warn calls Logger.Warn on the default logger.
 func Warn(msg string, args ...any) {
-	Default().LogDepth(0, WarnLevel, msg, args...)
+	Default().LogDepth(0, LevelWarn, msg, args...)
 }
 
 // Error calls Logger.Error on the default logger.
 func Error(msg string, err error, args ...any) {
-	Default().logDepthErr(err, 0, ErrorLevel, msg, args...)
+	Default().logDepthErr(err, 0, LevelError, msg, args...)
 }
 
 // Log calls Logger.Log on the default logger.
diff --git a/slog/logger_test.go b/slog/logger_test.go
index 0a50510..4a8bb4f 100644
--- a/slog/logger_test.go
+++ b/slog/logger_test.go
@@ -46,10 +46,10 @@
 	l.Error("bad", io.EOF, "a", 1)
 	check(`level=ERROR msg=bad a=1 err=EOF`)
 
-	l.Log(WarnLevel+1, "w", Int("a", 1), String("b", "two"))
+	l.Log(LevelWarn+1, "w", Int("a", 1), String("b", "two"))
 	check(`level=WARN\+1 msg=w a=1 b=two`)
 
-	l.LogAttrs(InfoLevel+1, "a b c", Int("a", 1), String("b", "two"))
+	l.LogAttrs(LevelInfo+1, "a b c", Int("a", 1), String("b", "two"))
 	check(`level=INFO\+1 msg="a b c" a=1 b=two`)
 
 	l.Info("info", "a", []Attr{Int("i", 1)})
@@ -168,9 +168,9 @@
 	startLine = f.Line + 4
 	// Do not change the number of lines between here and the call to check(0).
 
-	logger.Log(InfoLevel, "")
+	logger.Log(LevelInfo, "")
 	check(0)
-	logger.LogAttrs(InfoLevel, "")
+	logger.LogAttrs(LevelInfo, "")
 	check(1)
 	logger.Debug("")
 	check(2)
@@ -188,9 +188,9 @@
 	check(8)
 	Error("", nil)
 	check(9)
-	Log(InfoLevel, "")
+	Log(LevelInfo, "")
 	check(10)
-	LogAttrs(InfoLevel, "")
+	LogAttrs(LevelInfo, "")
 	check(11)
 }
 
@@ -209,7 +209,7 @@
 		wantAllocs(t, 0, func() { dl.Info("hello") })
 	})
 	t.Run("logger.Log", func(t *testing.T) {
-		wantAllocs(t, 0, func() { dl.Log(DebugLevel, "hello") })
+		wantAllocs(t, 0, func() { dl.Log(LevelDebug, "hello") })
 	})
 	t.Run("2 pairs", func(t *testing.T) {
 		s := "abc"
@@ -226,7 +226,7 @@
 		s := "abc"
 		i := 2000
 		wantAllocs(t, 2, func() {
-			l.Log(InfoLevel, "hello",
+			l.Log(LevelInfo, "hello",
 				"n", i,
 				"s", s,
 			)
@@ -237,8 +237,8 @@
 		s := "abc"
 		i := 2000
 		wantAllocs(t, 0, func() {
-			if l.Enabled(InfoLevel) {
-				l.Log(InfoLevel, "hello",
+			if l.Enabled(LevelInfo) {
+				l.Log(LevelInfo, "hello",
 					"n", i,
 					"s", s,
 				)
@@ -260,30 +260,30 @@
 		wantAllocs(t, 0, func() { dl.Info("", "error", io.EOF) })
 	})
 	t.Run("attrs1", func(t *testing.T) {
-		wantAllocs(t, 0, func() { dl.LogAttrs(InfoLevel, "", Int("a", 1)) })
-		wantAllocs(t, 0, func() { dl.LogAttrs(InfoLevel, "", Any("error", io.EOF)) })
+		wantAllocs(t, 0, func() { dl.LogAttrs(LevelInfo, "", Int("a", 1)) })
+		wantAllocs(t, 0, func() { dl.LogAttrs(LevelInfo, "", Any("error", io.EOF)) })
 	})
 	t.Run("attrs3", func(t *testing.T) {
 		wantAllocs(t, 0, func() {
-			dl.LogAttrs(InfoLevel, "hello", Int("a", 1), String("b", "two"), Duration("c", time.Second))
+			dl.LogAttrs(LevelInfo, "hello", Int("a", 1), String("b", "two"), Duration("c", time.Second))
 		})
 	})
 	t.Run("attrs3 disabled", func(t *testing.T) {
 		logger := New(discardHandler{disabled: true})
 		wantAllocs(t, 0, func() {
-			logger.LogAttrs(InfoLevel, "hello", Int("a", 1), String("b", "two"), Duration("c", time.Second))
+			logger.LogAttrs(LevelInfo, "hello", Int("a", 1), String("b", "two"), Duration("c", time.Second))
 		})
 	})
 	t.Run("attrs6", func(t *testing.T) {
 		wantAllocs(t, 1, func() {
-			dl.LogAttrs(InfoLevel, "hello",
+			dl.LogAttrs(LevelInfo, "hello",
 				Int("a", 1), String("b", "two"), Duration("c", time.Second),
 				Int("d", 1), String("e", "two"), Duration("f", time.Second))
 		})
 	})
 	t.Run("attrs9", func(t *testing.T) {
 		wantAllocs(t, 1, func() {
-			dl.LogAttrs(InfoLevel, "hello",
+			dl.LogAttrs(LevelInfo, "hello",
 				Int("a", 1), String("b", "two"), Duration("c", time.Second),
 				Int("d", 1), String("e", "two"), Duration("f", time.Second),
 				Int("d", 1), String("e", "two"), Duration("f", time.Second))
@@ -421,34 +421,34 @@
 	b.Run("attrs", func(b *testing.B) {
 		b.ReportAllocs()
 		for i := 0; i < b.N; i++ {
-			l.LogAttrs(InfoLevel, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
+			l.LogAttrs(LevelInfo, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
 		}
 	})
 	b.Run("attrs-parallel", func(b *testing.B) {
 		b.ReportAllocs()
 		b.RunParallel(func(pb *testing.PB) {
 			for pb.Next() {
-				l.LogAttrs(InfoLevel, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
+				l.LogAttrs(LevelInfo, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
 			}
 		})
 	})
 	b.Run("keys-values", func(b *testing.B) {
 		b.ReportAllocs()
 		for i := 0; i < b.N; i++ {
-			l.Log(InfoLevel, "msg", "a", 1, "b", "two", "c", true)
+			l.Log(LevelInfo, "msg", "a", 1, "b", "two", "c", true)
 		}
 	})
 	b.Run("WithContext", func(b *testing.B) {
 		b.ReportAllocs()
 		for i := 0; i < b.N; i++ {
-			l.WithContext(ctx).LogAttrs(InfoLevel, "msg2", Int("a", 1), String("b", "two"), Bool("c", true))
+			l.WithContext(ctx).LogAttrs(LevelInfo, "msg2", Int("a", 1), String("b", "two"), Bool("c", true))
 		}
 	})
 	b.Run("WithContext-parallel", func(b *testing.B) {
 		b.ReportAllocs()
 		b.RunParallel(func(pb *testing.PB) {
 			for pb.Next() {
-				l.WithContext(ctx).LogAttrs(InfoLevel, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
+				l.WithContext(ctx).LogAttrs(LevelInfo, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
 			}
 		})
 	})
@@ -458,7 +458,7 @@
 		defer SetDefault(dl)
 		b.ReportAllocs()
 		for i := 0; i < b.N; i++ {
-			Ctx(ctx).LogAttrs(InfoLevel, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
+			Ctx(ctx).LogAttrs(LevelInfo, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
 		}
 	})
 }
diff --git a/slog/record_test.go b/slog/record_test.go
index 78ebf46..1531254 100644
--- a/slog/record_test.go
+++ b/slog/record_test.go
@@ -90,7 +90,7 @@
 }
 
 func newRecordWithAttrs(as []Attr) Record {
-	r := NewRecord(time.Now(), InfoLevel, "", 0, nil)
+	r := NewRecord(time.Now(), LevelInfo, "", 0, nil)
 	r.AddAttrs(as...)
 	return r
 }
@@ -117,7 +117,7 @@
 }
 
 func BenchmarkSourceLine(b *testing.B) {
-	r := NewRecord(time.Now(), InfoLevel, "", 5, nil)
+	r := NewRecord(time.Now(), LevelInfo, "", 5, nil)
 	b.Run("alone", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
 			file, line := r.SourceLine()
@@ -144,7 +144,7 @@
 	var a Attr
 
 	for i := 0; i < b.N; i++ {
-		r := NewRecord(time.Time{}, InfoLevel, "", 0, nil)
+		r := NewRecord(time.Time{}, LevelInfo, "", 0, nil)
 		for j := 0; j < nAttrs; j++ {
 			r.AddAttrs(Int("k", j))
 		}
diff --git a/slog/text_handler_test.go b/slog/text_handler_test.go
index 2e4dcc2..47fe2b0 100644
--- a/slog/text_handler_test.go
+++ b/slog/text_handler_test.go
@@ -72,7 +72,7 @@
 				t.Run(opts.name, func(t *testing.T) {
 					var buf bytes.Buffer
 					h := opts.opts.NewTextHandler(&buf)
-					r := NewRecord(testTime, InfoLevel, "a message", 0, nil)
+					r := NewRecord(testTime, LevelInfo, "a message", 0, nil)
 					r.AddAttrs(test.attr)
 					if err := h.Handle(r); err != nil {
 						t.Fatal(err)
@@ -114,7 +114,7 @@
 func TestTextHandlerSource(t *testing.T) {
 	var buf bytes.Buffer
 	h := HandlerOptions{AddSource: true}.NewTextHandler(&buf)
-	r := NewRecord(testTime, InfoLevel, "m", 2, nil)
+	r := NewRecord(testTime, LevelInfo, "m", 2, nil)
 	if err := h.Handle(r); err != nil {
 		t.Fatal(err)
 	}
@@ -155,7 +155,7 @@
 }
 
 func TestTextHandlerAlloc(t *testing.T) {
-	r := NewRecord(time.Now(), InfoLevel, "msg", 0, nil)
+	r := NewRecord(time.Now(), LevelInfo, "msg", 0, nil)
 	for i := 0; i < 10; i++ {
 		r.AddAttrs(Int("x = y", i))
 	}
diff --git a/slog/value_test.go b/slog/value_test.go
index 7de63bd..f3b0db3 100644
--- a/slog/value_test.go
+++ b/slog/value_test.go
@@ -110,13 +110,13 @@
 	// Because typical Levels are small integers,
 	// they are zero-alloc.
 	var a Value
-	x := DebugLevel + 100
+	x := LevelDebug + 100
 	wantAllocs(t, 0, func() { a = AnyValue(x) })
 	_ = a
 }
 
 func TestAnyLevel(t *testing.T) {
-	x := DebugLevel + 100
+	x := LevelDebug + 100
 	v := AnyValue(x)
 	vv := v.Any()
 	if _, ok := vv.(Level); !ok {