diff --git a/_content/blog/examples.md b/_content/blog/examples.md
index 6133e04..e65f6e8 100644
--- a/_content/blog/examples.md
+++ b/_content/blog/examples.md
@@ -36,43 +36,44 @@
 Unlike normal test functions, though, example functions take no arguments
 and begin with the word `Example` instead of `Test`.
 
-The [`stringutil` package](https://pkg.go.dev/golang.org/x/example/stringutil/)
+The [`reverse` package](https://pkg.go.dev/golang.org/x/example/hello/reverse/)
 is part of the [Go example repository](https://cs.opensource.google/go/x/example).
-Here's an example that demonstrates its `Reverse` function:
+Here's an example that demonstrates its `String` function:
 
-	package stringutil_test
+	package reverse_test
 
 	import (
 		"fmt"
 
-		"golang.org/x/example/stringutil"
+		"golang.org/x/example/hello/reverse"
 	)
 
-	func ExampleReverse() {
-		fmt.Println(stringutil.Reverse("hello"))
+	func ExampleString() {
+		fmt.Println(reverse.String("hello"))
 		// Output: olleh
 	}
 
-This code might live in `example_test.go` in the `stringutil` directory.
+This code might live in `example_test.go` in the `reverse` directory.
 
-Godoc will present this example alongside the `Reverse` function's documentation:
+The Go package documentation server _pkg.go.dev_ presents this
+example alongside the [`String` function's documentation](https://pkg.go.dev/golang.org/x/example/hello/reverse/#String):
 
-{{image "examples/reverse.png"}}
+{{image "examples/pkgdoc.png" 517}}
 
 Running the package's test suite, we can see the example function is executed
 with no further arrangement from us:
 
 	$ go test -v
-	=== RUN TestReverse
-	--- PASS: TestReverse (0.00s)
-	=== RUN: ExampleReverse
-	--- PASS: ExampleReverse (0.00s)
+	=== RUN   TestString
+	--- PASS: TestString (0.00s)
+	=== RUN   ExampleString
+	--- PASS: ExampleString (0.00s)
 	PASS
-	ok  	golang.org/x/example/stringutil	0.009s
+	ok  	golang.org/x/example/hello/reverse	0.209s
 
 ## Output comments
 
-What does it mean that the `ExampleReverse` function "passes"?
+What does it mean that the `ExampleString` function "passes"?
 
 As it executes the example,
 the testing framework captures data written to standard output
@@ -82,15 +83,15 @@
 To see a failing example we can change the output comment text to something
 obviously incorrect
 
-	func ExampleReverse() {
-		fmt.Println(stringutil.Reverse("hello"))
+	func ExampleString() {
+		fmt.Println(reverse.String("hello"))
 		// Output: golly
 	}
 
 and run the tests again:
 
 	$ go test
-	--- FAIL: ExampleReverse (0.00s)
+	--- FAIL: ExampleString (0.00s)
 	got:
 	olleh
 	want:
@@ -99,17 +100,17 @@
 
 If we remove the output comment entirely
 
-	func ExampleReverse() {
-		fmt.Println(stringutil.Reverse("hello"))
+	func ExampleString() {
+		fmt.Println(reverse.String("hello"))
 	}
 
 then the example function is compiled but not executed:
 
 	$ go test -v
-	=== RUN TestReverse
-	--- PASS: TestReverse (0.00s)
+	=== RUN   TestString
+	--- PASS: TestString (0.00s)
 	PASS
-	ok  	golang.org/x/example/stringutil	0.009s
+	ok  	golang.org/x/example/hello/reverse	0.110s
 
 Examples without output comments are useful for demonstrating code that cannot
 run as unit tests, such as that which accesses the network,
@@ -124,16 +125,16 @@
 	func ExampleBar_Qux() // documents the Qux method of type Bar
 	func Example()        // documents the package as a whole
 
-Following this convention, godoc displays the `ExampleReverse` example
-alongside the documentation for the `Reverse` function.
+Following this convention, godoc displays the `ExampleString` example
+alongside the documentation for the `String` function.
 
 Multiple examples can be provided for a given identifier by using a suffix
 beginning with an underscore followed by a lowercase letter.
-Each of these examples documents the `Reverse` function:
+Each of these examples documents the `String` function:
 
-	func ExampleReverse()
-	func ExampleReverse_second()
-	func ExampleReverse_third()
+	func ExampleString()
+	func ExampleString_second()
+	func ExampleString_third()
 
 ## Larger examples
 
diff --git a/_content/blog/examples/pkgdoc.png b/_content/blog/examples/pkgdoc.png
new file mode 100644
index 0000000..b28d7b5
--- /dev/null
+++ b/_content/blog/examples/pkgdoc.png
Binary files differ
diff --git a/_content/doc/code.html b/_content/doc/code.html
index 79ec9bb..5616f1c 100644
--- a/_content/doc/code.html
+++ b/_content/doc/code.html
@@ -12,13 +12,6 @@
 fetch, build, and install Go modules, packages, and commands.
 </p>
 
-<p>
-Note: This document assumes that you are using Go 1.13 or later and the
-<code>GO111MODULE</code> environment variable is not set. If you are looking for
-the older, pre-modules version of this document, it is archived
-<a href="gopath_code.html">here</a>.
-</p>
-
 <h2 id="Organization">Code organization</h2>
 
 <p>
diff --git a/_content/doc/gopath_code.html b/_content/doc/gopath_code.html
index 6c3b536..47f4e62 100644
--- a/_content/doc/gopath_code.html
+++ b/_content/doc/gopath_code.html
@@ -1,649 +1,3 @@
 <!--{
-	"Title": "How to Write Go Code (with GOPATH)",
-	"Breadcrumb": true
+	"Redirect": "/doc/code"
 }-->
-
-<h2 id="Introduction">Introduction</h2>
-
-<p><b>
-If you are new to Go, please see the more recent
-<a href="code.html">How to Write Go Code</a>.
-</b></p>
-
-<p>
-This document demonstrates the development of a simple Go package and
-introduces the <a href="/cmd/go/">go tool</a>, the standard way to fetch,
-build, and install Go packages and commands.
-</p>
-
-<p>
-The <code>go</code> tool requires you to organize your code in a specific
-way. Please read this document carefully.
-It explains the simplest way to get up and running with your Go installation.
-</p>
-
-<p>
-A similar explanation is available as a
-<a href="https://www.youtube.com/watch?v=XCsL89YtqCs">screencast</a>.
-</p>
-
-
-<h2 id="Organization">Code organization</h2>
-
-<h3 id="Overview">Overview</h3>
-
-<ul>
-	<li>Go programmers typically keep all their Go code in a single <i>workspace</i>.</li>
-	<li>A workspace contains many version control <i>repositories</i>
-	    (managed by Git, for example).</li>
-	<li>Each repository contains one or more <i>packages</i>.</li>
-	<li>Each package consists of one or more Go source files in a single directory.</li>
-	<li>The path to a package's directory determines its <i>import path</i>.</li>
-</ul>
-
-<p>
-Note that this differs from other programming environments in which every
-project has a separate workspace and workspaces are closely tied to version
-control repositories.
-</p>
-
-<h3 id="Workspaces">Workspaces</h3>
-
-<p>
-A workspace is a directory hierarchy with two directories at its root:
-</p>
-
-<ul>
-<li><code>src</code> contains Go source files, and
-<li><code>bin</code> contains executable commands.
-</ul>
-
-<p>
-The <code>go</code> tool builds and installs binaries to the <code>bin</code> directory.
-</p>
-
-<p>
-The <code>src</code> subdirectory typically contains multiple version control
-repositories (such as for Git or Mercurial) that track the development of one
-or more source packages.
-</p>
-
-<p>
-To give you an idea of how a workspace looks in practice, here's an example:
-</p>
-
-<pre>
-bin/
-    hello                          # command executable
-    outyet                         # command executable
-src/
-    <a href="https://golang.org/x/example">golang.org/x/example/</a>
-        .git/                      # Git repository metadata
-	hello/
-	    hello.go               # command source
-	outyet/
-	    main.go                # command source
-	    main_test.go           # test source
-	stringutil/
-	    reverse.go             # package source
-	    reverse_test.go        # test source
-    <a href="https://golang.org/x/image/">golang.org/x/image/</a>
-        .git/                      # Git repository metadata
-	bmp/
-	    reader.go              # package source
-	    writer.go              # package source
-    ... (many more repositories and packages omitted) ...
-</pre>
-
-<p>
-The tree above shows a workspace containing two repositories
-(<code>example</code> and <code>image</code>).
-The <code>example</code> repository contains two commands (<code>hello</code>
-and <code>outyet</code>) and one library (<code>stringutil</code>).
-The <code>image</code> repository contains the <code>bmp</code> package
-and <a href="https://pkg.go.dev/golang.org/x/image">several others</a>.
-</p>
-
-<p>
-A typical workspace contains many source repositories containing many
-packages and commands. Most Go programmers keep <i>all</i> their Go source code
-and dependencies in a single workspace.
-</p>
-
-<p>
-Note that symbolic links should <b>not</b> be used to link files or directories into your workspace.
-</p>
-
-<p>
-Commands and libraries are built from different kinds of source packages.
-We will discuss the distinction <a href="#PackageNames">later</a>.
-</p>
-
-
-<h3 id="GOPATH">The <code>GOPATH</code> environment variable</h3>
-
-<p>
-The <code>GOPATH</code> environment variable specifies the location of your
-workspace. It defaults to a directory named <code>go</code> inside your home directory,
-so <code>$HOME/go</code> on Unix,
-<code>$home/go</code> on Plan 9,
-and <code>%USERPROFILE%\go</code> (usually <code>C:\Users\YourName\go</code>) on Windows.
-</p>
-
-<p>
-If you would like to work in a different location, you will need to
-<a href="/wiki/SettingGOPATH">set <code>GOPATH</code></a>
-to the path to that directory.
-(Another common setup is to set <code>GOPATH=$HOME</code>.)
-Note that <code>GOPATH</code> must <b>not</b> be the
-same path as your Go installation.
-</p>
-
-<p>
-The command <code>go</code> <code>env</code> <code>GOPATH</code>
-prints the effective current <code>GOPATH</code>;
-it prints the default location if the environment variable is unset.
-</p>
-
-<p>
-For convenience, add the workspace's <code>bin</code> subdirectory
-to your <code>PATH</code>:
-</p>
-
-<pre>
-$ <b>export PATH=$PATH:$(go env GOPATH)/bin</b>
-</pre>
-
-<p>
-The scripts in the rest of this document use <code>$GOPATH</code>
-instead of <code>$(go env GOPATH)</code> for brevity.
-To make the scripts run as written
-if you have not set GOPATH,
-you can substitute $HOME/go in those commands
-or else run:
-</p>
-
-<pre>
-$ <b>export GOPATH=$(go env GOPATH)</b>
-</pre>
-
-<p>
-To learn more about the <code>GOPATH</code> environment variable, see
-<a href="/cmd/go/#hdr-GOPATH_environment_variable"><code>'go help gopath'</code></a>.
-</p>
-
-<h3 id="ImportPaths">Import paths</h3>
-
-<p>
-An <i>import path</i> is a string that uniquely identifies a package.
-A package's import path corresponds to its location inside a workspace
-or in a remote repository (explained below).
-</p>
-
-<p>
-The packages from the standard library are given short import paths such as
-<code>"fmt"</code> and <code>"net/http"</code>.
-For your own packages, you must choose a base path that is unlikely to
-collide with future additions to the standard library or other external
-libraries.
-</p>
-
-<p>
-If you keep your code in a source repository somewhere, then you should use the
-root of that source repository as your base path.
-For instance, if you have a <a href="https://github.com/">GitHub</a> account at
-<code>github.com/user</code>, that should be your base path.
-</p>
-
-<p>
-Note that you don't need to publish your code to a remote repository before you
-can build it. It's just a good habit to organize your code as if you will
-publish it someday. In practice you can choose any arbitrary path name,
-as long as it is unique to the standard library and greater Go ecosystem.
-</p>
-
-<p>
-We'll use <code>github.com/user</code> as our base path. Create a directory
-inside your workspace in which to keep source code:
-</p>
-
-<pre>
-$ <b>mkdir -p $GOPATH/src/github.com/user</b>
-</pre>
-
-
-<h3 id="Command">Your first program</h3>
-
-<p>
-To compile and run a simple program, first choose a package path (we'll use
-<code>github.com/user/hello</code>) and create a corresponding package directory
-inside your workspace:
-</p>
-
-<pre>
-$ <b>mkdir $GOPATH/src/github.com/user/hello</b>
-</pre>
-
-<p>
-Next, create a file named <code>hello.go</code> inside that directory,
-containing the following Go code.
-</p>
-
-<pre>
-package main
-
-import "fmt"
-
-func main() {
-	fmt.Println("Hello, world.")
-}
-</pre>
-
-<p>
-Now you can build and install that program with the <code>go</code> tool:
-</p>
-
-<pre>
-$ <b>go install github.com/user/hello</b>
-</pre>
-
-<p>
-Note that you can run this command from anywhere on your system. The
-<code>go</code> tool finds the source code by looking for the
-<code>github.com/user/hello</code> package inside the workspace specified by
-<code>GOPATH</code>.
-</p>
-
-<p>
-You can also omit the package path if you run <code>go install</code> from the
-package directory:
-</p>
-
-<pre>
-$ <b>cd $GOPATH/src/github.com/user/hello</b>
-$ <b>go install</b>
-</pre>
-
-<p>
-This command builds the <code>hello</code> command, producing an executable
-binary. It then installs that binary to the workspace's <code>bin</code>
-directory as <code>hello</code> (or, under Windows, <code>hello.exe</code>).
-In our example, that will be <code>$GOPATH/bin/hello</code>, which is
-<code>$HOME/go/bin/hello</code>.
-</p>
-
-<p>
-The <code>go</code> tool will only print output when an error occurs, so if
-these commands produce no output they have executed successfully.
-</p>
-
-<p>
-You can now run the program by typing its full path at the command line:
-</p>
-
-<pre>
-$ <b>$GOPATH/bin/hello</b>
-Hello, world.
-</pre>
-
-<p>
-Or, as you have added <code>$GOPATH/bin</code> to your <code>PATH</code>,
-just type the binary name:
-</p>
-
-<pre>
-$ <b>hello</b>
-Hello, world.
-</pre>
-
-<p>
-If you're using a source control system, now would be a good time to initialize
-a repository, add the files, and commit your first change. Again, this step is
-optional: you do not need to use source control to write Go code.
-</p>
-
-<pre>
-$ <b>cd $GOPATH/src/github.com/user/hello</b>
-$ <b>git init</b>
-Initialized empty Git repository in /home/user/go/src/github.com/user/hello/.git/
-$ <b>git add hello.go</b>
-$ <b>git commit -m "initial commit"</b>
-[master (root-commit) 0b4507d] initial commit
- 1 file changed, 7 insertion(+)
- create mode 100644 hello.go
-</pre>
-
-<p>
-Pushing the code to a remote repository is left as an exercise for the reader.
-</p>
-
-
-<h3 id="Library">Your first library</h3>
-
-<p>
-Let's write a library and use it from the <code>hello</code> program.
-</p>
-
-<p>
-Again, the first step is to choose a package path (we'll use
-<code>github.com/user/stringutil</code>) and create the package directory:
-</p>
-
-<pre>
-$ <b>mkdir $GOPATH/src/github.com/user/stringutil</b>
-</pre>
-
-<p>
-Next, create a file named <code>reverse.go</code> in that directory with the
-following contents.
-</p>
-
-<pre>
-// Package stringutil contains utility functions for working with strings.
-package stringutil
-
-// Reverse returns its argument string reversed rune-wise left to right.
-func Reverse(s string) string {
-	r := []rune(s)
-	for i, j := 0, len(r)-1; i &lt; len(r)/2; i, j = i+1, j-1 {
-		r[i], r[j] = r[j], r[i]
-	}
-	return string(r)
-}
-</pre>
-
-<p>
-Now, test that the package compiles with <code>go build</code>:
-</p>
-
-<pre>
-$ <b>go build github.com/user/stringutil</b>
-</pre>
-
-<p>
-Or, if you are working in the package's source directory, just:
-</p>
-
-<pre>
-$ <b>go build</b>
-</pre>
-
-<p>
-This won't produce an output file.
-Instead it saves the compiled package in the local build cache.
-</p>
-
-<p>
-After confirming that the <code>stringutil</code> package builds,
-modify your original <code>hello.go</code> (which is in
-<code>$GOPATH/src/github.com/user/hello</code>) to use it:
-</p>
-
-<pre>
-package main
-
-import (
-	"fmt"
-
-	<b>"github.com/user/stringutil"</b>
-)
-
-func main() {
-	fmt.Println(stringutil.Reverse("!oG ,olleH"))
-}
-</pre>
-
-<p>
-Install the <code>hello</code> program:
-</p>
-
-<pre>
-$ <b>go install github.com/user/hello</b>
-</pre>
-
-<p>
-Running the new version of the program, you should see a new, reversed message:
-</p>
-
-<pre>
-$ <b>hello</b>
-Hello, Go!
-</pre>
-
-<p>
-After the steps above, your workspace should look like this:
-</p>
-
-<pre>
-bin/
-    hello                 # command executable
-src/
-    github.com/user/
-        hello/
-            hello.go      # command source
-        stringutil/
-            reverse.go    # package source
-</pre>
-
-<h3 id="PackageNames">Package names</h3>
-
-<p>
-The first statement in a Go source file must be
-</p>
-
-<pre>
-package <i>name</i>
-</pre>
-
-<p>
-where <code><i>name</i></code> is the package's default name for imports.
-(All files in a package must use the same <code><i>name</i></code>.)
-</p>
-
-<p>
-Go's convention is that the package name is the last element of the
-import path: the package imported as "<code>crypto/rot13</code>"
-should be named <code>rot13</code>.
-</p>
-
-<p>
-Executable commands must always use <code>package main</code>.
-</p>
-
-<p>
-There is no requirement that package names be unique
-across all packages linked into a single binary,
-only that the import paths (their full file names) be unique.
-</p>
-
-<p>
-See <a href="/doc/effective_go.html#names">Effective Go</a> to learn more about
-Go's naming conventions.
-</p>
-
-
-<h2 id="Testing">Testing</h2>
-
-<p>
-Go has a lightweight test framework composed of the <code>go test</code>
-command and the <code>testing</code> package.
-</p>
-
-<p>
-You write a test by creating a file with a name ending in <code>_test.go</code>
-that contains functions named <code>TestXXX</code> with signature
-<code>func (t *testing.T)</code>.
-The test framework runs each such function;
-if the function calls a failure function such as <code>t.Error</code> or
-<code>t.Fail</code>, the test is considered to have failed.
-</p>
-
-<p>
-Add a test to the <code>stringutil</code> package by creating the file
-<code>$GOPATH/src/github.com/user/stringutil/reverse_test.go</code> containing
-the following Go code.
-</p>
-
-<pre>
-package stringutil
-
-import "testing"
-
-func TestReverse(t *testing.T) {
-	cases := []struct {
-		in, want string
-	}{
-		{"Hello, world", "dlrow ,olleH"},
-		{"Hello, 世界", "界世 ,olleH"},
-		{"", ""},
-	}
-	for _, c := range cases {
-		got := Reverse(c.in)
-		if got != c.want {
-			t.Errorf("Reverse(%q) == %q, want %q", c.in, got, c.want)
-		}
-	}
-}
-</pre>
-
-<p>
-Then run the test with <code>go test</code>:
-</p>
-
-<pre>
-$ <b>go test github.com/user/stringutil</b>
-ok  	github.com/user/stringutil 0.165s
-</pre>
-
-<p>
-As always, if you are running the <code>go</code> tool from the package
-directory, you can omit the package path:
-</p>
-
-<pre>
-$ <b>go test</b>
-ok  	github.com/user/stringutil 0.165s
-</pre>
-
-<p>
-Run <code><a href="/cmd/go/#hdr-Test_packages">go help test</a></code> and see the
-<a href="/pkg/testing/">testing package documentation</a> for more detail.
-</p>
-
-
-<h2 id="remote">Remote packages</h2>
-
-<p>
-An import path can describe how to obtain the package source code using a
-revision control system such as Git or Mercurial. The <code>go</code> tool uses
-this property to automatically fetch packages from remote repositories.
-For instance, the examples described in this document are also kept in a
-Git repository hosted at GitHub
-<code><a href="https://golang.org/x/example">golang.org/x/example</a></code>.
-If you include the repository URL in the package's import path,
-<code>go get</code> will fetch, build, and install it automatically:
-</p>
-
-<pre>
-$ <b>go get golang.org/x/example/hello</b>
-$ <b>$GOPATH/bin/hello</b>
-Hello, Go examples!
-</pre>
-
-<p>
-If the specified package is not present in a workspace, <code>go get</code>
-will place it inside the first workspace specified by <code>GOPATH</code>.
-(If the package does already exist, <code>go get</code> skips the remote
-fetch and behaves the same as <code>go install</code>.)
-</p>
-
-<p>
-After issuing the above <code>go get</code> command, the workspace directory
-tree should now look like this:
-</p>
-
-<pre>
-bin/
-    hello                           # command executable
-src/
-    golang.org/x/example/
-	.git/                       # Git repository metadata
-        hello/
-            hello.go                # command source
-        stringutil/
-            reverse.go              # package source
-            reverse_test.go         # test source
-    github.com/user/
-        hello/
-            hello.go                # command source
-        stringutil/
-            reverse.go              # package source
-            reverse_test.go         # test source
-</pre>
-
-<p>
-The <code>hello</code> command hosted at GitHub depends on the
-<code>stringutil</code> package within the same repository. The imports in
-<code>hello.go</code> file use the same import path convention, so the
-<code>go get</code> command is able to locate and install the dependent
-package, too.
-</p>
-
-<pre>
-import "golang.org/x/example/stringutil"
-</pre>
-
-<p>
-This convention is the easiest way to make your Go packages available for
-others to use.
-<a href="https://pkg.go.dev">Pkg.go.dev</a>
-and the <a href="/wiki/Projects">Go Wiki</a>
-provide lists of external Go projects.
-</p>
-
-<p>
-For more information on using remote repositories with the <code>go</code> tool, see
-<code><a href="/cmd/go/#hdr-Remote_import_paths">go help importpath</a></code>.
-</p>
-
-
-<h2 id="next">What's next</h2>
-
-<p>
-Subscribe to the
-<a href="https://groups.google.com/group/golang-announce">golang-announce</a>
-mailing list to be notified when a new stable version of Go is released.
-</p>
-
-<p>
-See <a href="/doc/effective_go.html">Effective Go</a> for tips on writing
-clear, idiomatic Go code.
-</p>
-
-<p>
-Take <a href="/tour/">A Tour of Go</a> to learn the language
-proper.
-</p>
-
-<p>
-Visit the <a href="/doc/#articles">documentation page</a> for a set of in-depth
-articles about the Go language and its libraries and tools.
-</p>
-
-
-<h2 id="help">Getting help</h2>
-
-<p>
-For real-time help, ask the helpful gophers in <code>#go-nuts</code> on the
-<a href="https://libera.chat/">Libera.Chat</a> IRC server.
-</p>
-
-<p>
-The official mailing list for discussion of the Go language is
-<a href="https://groups.google.com/group/golang-nuts">Go Nuts</a>.
-</p>
-
-<p>
-Report bugs using the
-<a href="/issue">Go issue tracker</a>.
-</p>
diff --git a/_content/doc/tutorial/workspaces.md b/_content/doc/tutorial/workspaces.md
index 410a630..2df1cfc 100644
--- a/_content/doc/tutorial/workspaces.md
+++ b/_content/doc/tutorial/workspaces.md
@@ -67,10 +67,10 @@
    go: creating new go.mod: module example.com/hello
    ```
 
-   Add a dependency on the golang.org/x/example module by using `go get`.
+   Add a dependency on the golang.org/x/example/hello/reverse package by using `go get`.
 
    ```
-   $ go get golang.org/x/example
+   $ go get golang.org/x/example/hello/reverse
    ```
 
    Create hello.go in the hello directory with the following contents:
@@ -81,18 +81,18 @@
    import (
        "fmt"
 
-       "golang.org/x/example/stringutil"
+       "golang.org/x/example/hello/reverse"
    )
 
    func main() {
-       fmt.Println(stringutil.Reverse("Hello"))
+       fmt.Println(reverse.String("Hello"))
    }
    ```
 
    Now, run the hello program:
 
    ```
-   $ go run example.com/hello
+   $ go run .
    olleH
    ```
 
@@ -136,7 +136,7 @@
 In the `workspace` directory, run:
 
    ```
-   $ go run example.com/hello
+   $ go run ./hello
    olleH
    ```
 
@@ -145,12 +145,13 @@
 outside the module or the workspace would result in an error because the `go` command
 wouldn't know which modules to use.
 
-Next, we'll add a local copy of the `golang.org/x/example` module to the workspace. We'll then
-add a new function to the `stringutil` package that we can use instead of `Reverse`.
+Next, we'll add a local copy of the `golang.org/x/example/hello` module to the workspace.
+That module is stored in a subdirectory of the `go.googlesource.com/example` Git repository.
+We'll then add a new function to the `reverse` package that we can use instead of `String`.
 
-## Download and modify the `golang.org/x/example` module
+## Download and modify the `golang.org/x/example/hello` module
 
-   In this step, we'll download a copy of the Git repo containing the `golang.org/x/example` module,
+   In this step, we'll download a copy of the Git repo containing the `golang.org/x/example/hello` module,
    add it to the workspace, and then add a new function to it that we will use from the hello program.
 
 1. Clone the repository
@@ -167,8 +168,12 @@
 
 2. Add the module to the workspace
 
+   The Git repo was just checked out into `./example`.
+   The source code for the `golang.org/x/example/hello` module is in `./example/hello`.
+   Add it to the workspace:
+
    ```
-   $ go work use ./example
+   $ go work use ./example/hello
    ```
 
    The `go work use` command adds a new module to the go.work file. It will now look like this:
@@ -178,33 +183,32 @@
 
    use (
        ./hello
-       ./example
+       ./example/hello
    )
    ```
 
-   The module now includes both the `example.com/hello` module and the `golang.org/x/example` module.
+   The module now includes both the `example.com/hello` module and the `golang.org/x/example/hello` module,
+   which provides the `golang.org/x/example/hello/reverse` package.
 
-   This will allow us to use the new code we will write in our copy of the `stringutil` module
-   instead of the version of the module in the module cache that we downloaded with the `go get` command.
+   This will allow us to use the new code we will write in our copy of the `reverse` package
+   instead of the version of the package in the module cache
+   that we downloaded with the `go get` command.
 
 3. Add the new function.
 
-   We'll add a new function to uppercase a string to the `golang.org/x/example/stringutil` package.
+   We'll add a new function to reverse a number to the `golang.org/x/example/hello/reverse` package.
 
-   Create a new file named `toupper.go` in the `workspace/example/stringutil` directory containing the following contents:
+   Create a new file named `int.go` in the `workspace/example/hello/reverse` directory containing the following contents:
 
    ```
-   package stringutil
+   package reverse
 
-   import "unicode"
+   import "strconv"
 
-   // ToUpper uppercases all the runes in its argument string.
-   func ToUpper(s string) string {
-       r := []rune(s)
-       for i := range r {
-           r[i] = unicode.ToUpper(r[i])
-       }
-       return string(r)
+   // Int returns the decimal reversal of the integer i.
+   func Int(i int) int {
+       i, _ = strconv.Atoi(String(strconv.Itoa(i)))
+       return i
    }
    ```
 
@@ -218,11 +222,11 @@
    import (
        "fmt"
 
-       "golang.org/x/example/stringutil"
+       "golang.org/x/example/hello/reverse"
    )
 
    func main() {
-       fmt.Println(stringutil.ToUpper("Hello"))
+       fmt.Println(reverse.String("Hello"), reverse.Int(24601))
    }
    ```
 
@@ -231,13 +235,13 @@
    From the workspace directory, run
 
    ```
-   $ go run example.com/hello
-   HELLO
+   $ go run ./hello
+   olleH 10642
    ```
 
    The Go command finds the `example.com/hello` module specified in the
    command line in the `hello` directory specified by the `go.work`
-   file, and similarly resolves the `golang.org/x/example` import using
+   file, and similarly resolves the `golang.org/x/example/hello/reverse` import using
    the `go.work` file.
 
    `go.work` can be used instead of adding [`replace`](https://go.dev/ref/mod#go-mod-file-replace)
@@ -248,16 +252,16 @@
 
 #### Future step
 
-   Now, to properly release these modules we'd need to make a release of the `golang.org/x/example`
+   Now, to properly release these modules we'd need to make a release of the `golang.org/x/example/hello`
    module, for example at `v0.1.0`. This is usually done by tagging a commit on the module's version
    control repository. See the
    [module release workflow documentation](https://go.dev/doc/modules/release-workflow)
    for more details. Once the release is done, we can increase the requirement on the
-   `golang.org/x/example` module in `hello/go.mod`:
+   `golang.org/x/example/hello` module in `hello/go.mod`:
 
    ```
    cd hello
-   go get golang.org/x/example@v0.1.0
+   go get golang.org/x/example/hello@v0.1.0
    ```
 
    That way, the `go` command can properly resolve the modules outside the workspace.