diff --git a/cmd/writeas/api.go b/cmd/writeas/api.go
index cb9f05b..c4d3e62 100644
--- a/cmd/writeas/api.go
+++ b/cmd/writeas/api.go
@@ -1,151 +1,146 @@
 package main
 
 import (
 	"fmt"
 	"github.com/atotto/clipboard"
 	"github.com/writeas/go-writeas"
 	"gopkg.in/urfave/cli.v1"
 )
 
 const (
 	defaultUserAgent = "writeas-cli v" + version
 )
 
 func client(userAgent string, tor bool) *writeas.Client {
 	var client *writeas.Client
 	if tor {
 		client = writeas.NewTorClient(torPort)
 	} else {
 		client = writeas.NewClient()
 	}
 	client.UserAgent = userAgent
 
 	return client
 }
 
 // DoFetch retrieves the Write.as post with the given friendlyID,
 // optionally via the Tor hidden service.
 func DoFetch(friendlyID, ua string, tor bool) error {
 	cl := client(ua, tor)
 
 	p, err := cl.GetPost(friendlyID)
 	if err != nil {
 		return err
 	}
 
 	fmt.Printf("%s\n", string(p.Content))
 	return nil
 }
 
 // DoPost creates a Write.as post, returning an error if it was
 // unsuccessful.
 func DoPost(c *cli.Context, post []byte, font string, encrypt, tor, code bool) error {
 	cl := client(userAgent(c), tor)
 
 	p, err := cl.CreatePost(&writeas.PostParams{
 		// TODO: extract title
 		Content: string(post),
 		Font:    getFont(code, font),
 	})
 	if err != nil {
 		return fmt.Errorf("Unable to post: %v", err)
 	}
 
 	url := writeasBaseURL
 	if tor {
 		url = torBaseURL
 	}
 	url += "/" + p.ID
 
 	// Store post locally
 	addPost(p.ID, p.Token)
 
 	// Copy URL to clipboard
 	err = clipboard.WriteAll(string(url))
 	if err != nil {
 		Errorln("writeas: Didn't copy to clipboard: %s", err)
 	} else {
 		Info(c, "Copied to clipboard.")
 	}
 
 	// Output URL
 	fmt.Printf("%s\n", url)
 
 	return nil
 }
 
 // DoUpdate updates the given post on Write.as.
 func DoUpdate(c *cli.Context, post []byte, friendlyID, token, font string, tor, code bool) error {
 	cl := client(userAgent(c), tor)
 
 	params := writeas.PostParams{
 		ID:      friendlyID,
 		Token:   token,
 		Content: string(post),
 		// TODO: extract title
 	}
 	if code || font != "" {
 		params.Font = getFont(code, font)
 	}
 
 	_, err := cl.UpdatePost(&params)
 	if err != nil {
 		if debug {
 			ErrorlnQuit("Problem updating: %v", err)
 		}
 		return fmt.Errorf("Post doesn't exist, or bad edit token given.")
 	}
 
 	if tor {
 		Info(c, "Post updated via hidden service.")
 	} else {
 		Info(c, "Post updated.")
 	}
 	return nil
 }
 
 // DoDelete deletes the given post on Write.as.
 func DoDelete(c *cli.Context, friendlyID, token string, tor bool) error {
 	cl := client(userAgent(c), tor)
 
 	err := cl.DeletePost(&writeas.PostParams{
 		ID:    friendlyID,
 		Token: token,
 	})
 	if err != nil {
 		if debug {
 			ErrorlnQuit("Problem deleting: %v", err)
 		}
 		return fmt.Errorf("Post doesn't exist, or bad edit token given.")
 	}
 
 	if tor {
 		Info(c, "Post deleted from hidden service.")
 	} else {
 		Info(c, "Post deleted.")
 	}
 	removePost(friendlyID)
 
 	return nil
 }
 
-func DoLogIn(c *cli.Context, username, password string) error {
+func DoLogIn(c *cli.Context, uc *UserConfig, username, password string) error {
 	cl := client(userAgent(c), isTor(c))
 
-	uc, err := loadConfig()
-	if err != nil {
-		return cli.NewExitError(fmt.Sprintf("couldn't load config: %v", err), 1)
-	}
-
 	u, err := cl.LogIn(username, password)
 	if err != nil {
 		if debug {
 			ErrorlnQuit("Problem logging in: %v", err)
 		}
 		return err
 	}
 
 	uc.API.Token = u.AccessToken
 	Info(c, "Success.")
 	return saveConfig(uc)
 }
diff --git a/cmd/writeas/commands.go b/cmd/writeas/commands.go
index 34cb87b..1db023d 100644
--- a/cmd/writeas/commands.go
+++ b/cmd/writeas/commands.go
@@ -1,173 +1,184 @@
 package main
 
 import (
 	"fmt"
 	"github.com/howeyc/gopass"
 	"gopkg.in/urfave/cli.v1"
 	"os"
 )
 
 func cmdPost(c *cli.Context) error {
 	err := handlePost(readStdIn(), c)
 	return err
 }
 
 func cmdNew(c *cli.Context) error {
 	fname, p := composeNewPost()
 	if p == nil {
 		// Assume composeNewPost already told us what the error was. Abort now.
 		os.Exit(1)
 	}
 
 	// Ensure we have something to post
 	if len(*p) == 0 {
 		// Clean up temporary post
 		if fname != "" {
 			os.Remove(fname)
 		}
 
 		InfolnQuit("Empty post. Bye!")
 	}
 
 	err := handlePost(*p, c)
 	if err != nil {
 		Errorln("Error posting: %s", err)
 		Errorln(messageRetryCompose(fname))
 		return cli.NewExitError("", 1)
 	}
 
 	// Clean up temporary post
 	if fname != "" {
 		os.Remove(fname)
 	}
 
 	return nil
 }
 
 func cmdDelete(c *cli.Context) error {
 	friendlyID := c.Args().Get(0)
 	token := c.Args().Get(1)
 	if friendlyID == "" {
 		return cli.NewExitError("usage: writeas delete <postId> [<token>]", 1)
 	}
 
 	if token == "" {
 		// Search for the token locally
 		token = tokenFromID(friendlyID)
 		if token == "" {
 			Errorln("Couldn't find an edit token locally. Did you create this post here?")
 			ErrorlnQuit("If you have an edit token, use: writeas delete %s <token>", friendlyID)
 		}
 	}
 
 	tor := isTor(c)
 	if c.Int("tor-port") != 0 {
 		torPort = c.Int("tor-port")
 	}
 	if tor {
 		Info(c, "Deleting via hidden service...")
 	} else {
 		Info(c, "Deleting...")
 	}
 
 	return DoDelete(c, friendlyID, token, tor)
 }
 
 func cmdUpdate(c *cli.Context) error {
 	friendlyID := c.Args().Get(0)
 	token := c.Args().Get(1)
 	if friendlyID == "" {
 		return cli.NewExitError("usage: writeas update <postId> [<token>]", 1)
 	}
 
 	if token == "" {
 		// Search for the token locally
 		token = tokenFromID(friendlyID)
 		if token == "" {
 			Errorln("Couldn't find an edit token locally. Did you create this post here?")
 			ErrorlnQuit("If you have an edit token, use: writeas update %s <token>", friendlyID)
 		}
 	}
 
 	// Read post body
 	fullPost := readStdIn()
 
 	tor := isTor(c)
 	if c.Int("tor-port") != 0 {
 		torPort = c.Int("tor-port")
 	}
 	if tor {
 		Info(c, "Updating via hidden service...")
 	} else {
 		Info(c, "Updating...")
 	}
 
 	return DoUpdate(c, fullPost, friendlyID, token, c.String("font"), tor, c.Bool("code"))
 }
 
 func cmdGet(c *cli.Context) error {
 	friendlyID := c.Args().Get(0)
 	if friendlyID == "" {
 		return cli.NewExitError("usage: writeas get <postId>", 1)
 	}
 
 	tor := isTor(c)
 	if c.Int("tor-port") != 0 {
 		torPort = c.Int("tor-port")
 	}
 	if tor {
 		Info(c, "Getting via hidden service...")
 	} else {
 		Info(c, "Getting...")
 	}
 
 	return DoFetch(friendlyID, userAgent(c), tor)
 }
 
 func cmdAdd(c *cli.Context) error {
 	friendlyID := c.Args().Get(0)
 	token := c.Args().Get(1)
 	if friendlyID == "" || token == "" {
 		return cli.NewExitError("usage: writeas add <postId> <token>", 1)
 	}
 
 	err := addPost(friendlyID, token)
 	return err
 }
 
 func cmdList(c *cli.Context) error {
 	urls := c.Bool("url")
 	ids := c.Bool("id")
 
 	var p Post
 	posts := getPosts()
 	for i := range *posts {
 		p = (*posts)[len(*posts)-1-i]
 		if ids || !urls {
 			fmt.Printf("%s ", p.ID)
 		}
 		if urls {
 			fmt.Printf("https://write.as/%s ", p.ID)
 		}
 		fmt.Print("\n")
 	}
 	return nil
 }
 
 func cmdAuth(c *cli.Context) error {
+	// Check configuration
+	uc, err := loadConfig()
+	if err != nil {
+		return cli.NewExitError(fmt.Sprintf("couldn't load config: %v", err), 1)
+	}
+	if uc != nil && uc.API.Token != "" {
+		return cli.NewExitError("You're already authenticated.", 1)
+	}
+
+	// Validate arguments and get password
 	username := c.String("u")
 	if username == "" {
 		return cli.NewExitError("usage: writeas auth -u <username>", 1)
 	}
 
 	fmt.Print("Password: ")
 	pass, err := gopass.GetPasswdMasked()
 	if err != nil {
 		return cli.NewExitError(fmt.Sprintf("error reading password: %v", err), 1)
 	}
+
 	// Validate password
 	if len(pass) == 0 {
 		return cli.NewExitError("Please enter your password.", 1)
 	}
-	return DoLogIn(c, username, string(pass))
+	return DoLogIn(c, uc, username, string(pass))
 }