diff --git a/tutorial/001-the-host/README.md b/tutorial/001-the-host/README.md
index dd87ac5117fbd9c754b868d119d5b6543956d3b2..66b91be5f70f8926b354dd57918b979753a9bae1 100644
--- a/tutorial/001-the-host/README.md
+++ b/tutorial/001-the-host/README.md
@@ -4,16 +4,25 @@ started. This guide will show how to construct and use a simple host.
 The host is an abstraction that manages services on top of a swarm. It provides
 a clean interface to connect to a service on a given remote peer.
 
-First, you'll need an ID, and a place to store that ID. To generate a 'test'
+First, you'll need an ID, and a place to store that ID. To generate an
 ID, you can do the following:
 ```go
 import (
-	testutil "github.com/libp2p/go-testutil"
+	"crypto/rand"
+
+	crypto "github.com/libp2p/go-libp2p-crypto"
+	peer "github.com/libp2p/go-libp2p-peer"
 	pstore "github.com/libp2p/go-libp2p-peerstore"
 )
 
-// For toy applications, this is an easy way to get an identity
-ident, err := testutil.RandIdentity()
+// Generate an identity keypair using go's cryptographic randomness source
+priv, pub, err := crypto.GenerateEd25519Key(rand.Reader)
+if err != nil {
+	panic(err)
+}
+
+// A peers ID is the hash of its public key
+pid, err := peer.IDFromPublicKey(pub)
 if err != nil {
 	panic(err)
 }
@@ -21,10 +30,8 @@ if err != nil {
 // We've created the identity, now we need to store it.
 // A peerstore holds information about peers, including your own
 ps := pstore.NewPeerstore()
-
-// An identity is essentially a public/private keypair
-ps.AddPrivKey(ident.ID(), ident.PrivateKey())
-ps.AddPubKey(ident.ID(), ident.PublicKey())
+ps.AddPrivKey(pid, priv)
+ps.AddPubKey(pid, priv)
 ```
 
 Next, you'll need at least one address that you want to listen on. You can go
diff --git a/tutorial/001-the-host/host.go b/tutorial/001-the-host/host.go
index 05b8b12844fb575cf0cea9580e7ec59f365a771b..9c028206ec08a2e7312661e70a771f92b1d180d0 100644
--- a/tutorial/001-the-host/host.go
+++ b/tutorial/001-the-host/host.go
@@ -2,18 +2,26 @@ package main
 
 import (
 	"context"
+	"crypto/rand"
 	"fmt"
 
+	crypto "github.com/libp2p/go-libp2p-crypto"
+	peer "github.com/libp2p/go-libp2p-peer"
 	pstore "github.com/libp2p/go-libp2p-peerstore"
 	swarm "github.com/libp2p/go-libp2p-swarm"
 	bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
-	testutil "github.com/libp2p/go-testutil"
 	ma "github.com/multiformats/go-multiaddr"
 )
 
 func main() {
-	// For toy applications, this is an easy way to get an identity
-	ident, err := testutil.RandIdentity()
+	// Generate an identity keypair using go's cryptographic randomness source
+	priv, pub, err := crypto.GenerateEd25519Key(rand.Reader)
+	if err != nil {
+		panic(err)
+	}
+
+	// A peers ID is the hash of its public key
+	pid, err := peer.IDFromPublicKey(pub)
 	if err != nil {
 		panic(err)
 	}
@@ -21,10 +29,8 @@ func main() {
 	// We've created the identity, now we need to store it.
 	// A peerstore holds information about peers, including your own
 	ps := pstore.NewPeerstore()
-
-	// An identity is essentially a public/private keypair
-	ps.AddPrivKey(ident.ID(), ident.PrivateKey())
-	ps.AddPubKey(ident.ID(), ident.PublicKey())
+	ps.AddPrivKey(pid, priv)
+	ps.AddPubKey(pid, pub)
 
 	maddr, err := ma.NewMultiaddr("/ip4/0.0.0.0/tcp/9000")
 	if err != nil {
@@ -35,7 +41,7 @@ func main() {
 	ctx := context.Background()
 
 	// Put all this together
-	netw, err := swarm.NewNetwork(ctx, []ma.Multiaddr{maddr}, ident.ID(), ps, nil)
+	netw, err := swarm.NewNetwork(ctx, []ma.Multiaddr{maddr}, pid, ps, nil)
 	if err != nil {
 		panic(err)
 	}