Update docs for using Convex without an account (#35962)

I updated the docs for "Dev workflow" to talk about both developing locally without an account vs. creating an account but tried to keep it short.

I also updated the docs on "Local deployments" to cover both anonymous development and using them linked with an account.

We could consider updating the "Production" docs with a backlink to "local deployments vs. production" for people who land there first.

GitOrigin-RevId: 13f6a8824afa9f51c1a911fbe754afba3844fd8c

Author: sshader

npm-packages/docs/docs/cli/local-deployments-for-dev.mdx

@@ -8,23 +8,22 @@ Instead of syncing code to a Convex dev deployment hosted in the cloud, you can
 develop against a deployment running on your own computer. You can even use the
 Convex dashboard with local deployments!
 
-## Background on Deployments in Convex
+## Background on deployments in Convex
 
 Each Convex deployment contains its own data, functions, scheduled functions,
-etc. A project has one production deployment, one cloud deployment for
+etc. A project has one production deployment, up to one cloud deployment for
 development per team member, and potentially many transient
-[preview deployments](/docs/testing.mdx).
+[preview deployments](/docs/production/hosting/preview-deployments.mdx).
 
-Running the deployment you're syncing code to during development on your own
-machine makes code sync faster and means resources like functions calls and
-database bandwidth don't count against
+You can also develop with Convex using a deployment running on your own machine.
+Since the deployment is running locally, code sync is faster and means resources
+like functions calls and database bandwidth don't count against
 [the quotas for your Convex plan](https://www.convex.dev/pricing).
 
-Local deployments are not recommended for production use: they're development
-deployments, i.e. logs for function results and full stack traces for error
-responses are sent to connected clients. For information about self-hosting a
-production deployment instead, see the
-[convex-backend GitHub repo](https://github.com/get-convex/convex-backend).
+You can use local deployments with an existing Convex project, and view your
+deployment in the Convex dashboard under your project. You can also use local
+deployments without a Convex account and debug and inspect them with a locally
+running version of the Convex dashboard.
 
 ## Using local deployments
 
@@ -33,23 +32,19 @@ production deployment instead, see the
 While using local deployments, the local Convex backend runs as a subprocess of
 the `npx convex dev` command and exits when that command is stopped. This means
 a `convex dev` command must be running in order to run other commands like
-`npx convex run` against this local deployment.
-
-State for local backends is stored the `~/.convex/convex-backend-state/`
-directory.
+`npx convex run` against this local deployment or for your frontend to connect
+to this deployment.
 
-### Using a Local Deployments for a New Project
+State for local backends is stored the `~/.convex/` directory.
 
-When creating a new project you can choose to start out with local development
-right away by choosing this option during project creation.
+### Anonymous development
 
-In addition to downloading the Convex backend binary and pushing your code to
-it, this command updates the `CONVEX_DEPLOYMENT` environment variable in your
-`.env.local` file so clients like webapps you're developing and Convex CLI
-commands like `npx convex dev` and `npx convex run` know to use the local
-deployment.
+You can use local deployments to develop with Convex without having to create an
+account. Whenever you want to create an account to deploy your app to production
+or to use more Convex features, you can use `npx convex login` to link your
+local deployments with your account.
 
-### Enabling for an Existing Project
+### Local deployments for an existing project
 
 To use a local deployment for an existing project, run:
 
@@ -62,6 +57,19 @@ You'll also always be given the option for a local deployment if you run
 in some situations, for example when connecting to a project for which you
 already have a cloud development deployment.
 
+## Local deployments vs. production
+
+Local deployments are not recommended for production use: they're development
+deployments, i.e. logs for function results and full stack traces for error
+responses are sent to connected clients.
+
+For running a production application, you can use a production deployment hosted
+on the Convex cloud. Learn more about deploying to production
+[here](/docs/production.mdx).
+
+Alternatively, you can self-host a production deployment using the
+[open source convex-backend repo](https://github.com/get-convex/convex-backend).
+
 ### Disabling
 
 To stop using local developments for a project, run the following:

npm-packages/docs/docs/understanding/workflow.mdx

@@ -19,40 +19,62 @@ You install Convex adding the npm dependency to your app:
 npm i convex
 ```
 
-Then you create your Convex project and start backend dev loop:
+Then you create your Convex project and start the backend dev loop:
 
 ```sh
 npx convex dev
 ```
 
-The first time you run the `npx convex dev` command you'll be asked to:
+The first time you run the `npx convex dev` command you'll be asked whether you
+want start developing locally without an account or create an account.
 
-1. Create an account if it doesn't exist
-   1. This adds your credentials to your `~/.convex/config.json` file. You can
-      run `npx convex logout` to log your machine out of the account in the
-      future.
-1. Create a new Convex project if it doesn't exist
+### Developing without an account
 
-Then Convex will automatically provision a new personal development deployment
-for this project for you:
+`npx convex dev` will prompt you for the name of your project, and then start
+running the open-source Convex backend locally on your machine (this is also
+called a "deployment").
+
+The data for your project will be saved in the `~/.convex` directory.
+
+1. The name of your project will get saved to your `.env.local` file so future
+   runs of `npx convex dev` will know to use this project.
+1. A `convex/` folder will be created (if it doesn't exist), where you'll write
+   your Convex backend functions.
+
+You can run `npx convex login` in the future to create an account and link any
+existing projects.
+
+### Developing with an account
+
+`npx convex dev` will prompt you through creating an account if one doesn't
+exist, and will add your credentials to `~/.convex/config.json` on your machine.
+You can run `npx convex logout` to log you machine out of the account in the
+future.
+
+Next, `npx convex dev` will create a new project and provision a new personal
+development deployment for this project:
 
 1.  Deployment details will automatically be added to your `.env.local` file so
-    future runs of `npx convex dev` will know what dev deployment to connect to.
+    future runs of `npx convex dev` will know which dev deployment to connect
+    to.
 1.  A `convex/` folder will be created (if it doesn't exist), where you'll write
     your Convex backend functions.
 
 <div className="center-image" style={{ maxWidth: "149px" }}>
   ![Convex directory in your app](/img/convex-directory.png)
 </div>
 
-## Developing your app
+## Running the dev loop
 
 Keep the `npx convex dev` command running while you're working on your Convex
 app. This continuously pushes backend code you write in the `convex/` folder to
-your dev deployment. It also keeps the necessary TypeScript types up-to-date as
-you write your backend code.
+your deployment. It also keeps the necessary TypeScript types up-to-date as you
+write your backend code.
+
+When you're developing with a locally running deployment, `npx convex dev` is
+also responsible for running your deployment.
 
-You can then add new new server functions to your Convex backend:
+You can then add new server functions to your Convex backend:
 
 ```typescript title="convex/tasks.ts"
 import { query } from "./_generated/server";
@@ -74,8 +96,9 @@ export const getTaskList = query({
 
 When you write and save this code in your editor, several things happen:
 
-1. The `npx convex dev` command uploads the contents of your `convex/` directory
-   to your dev deployment.
+1. The `npx convex dev` command typechecks your code and updates the
+   `convex/_generated` directory.
+1. The contents of your `convex/` directory get uploaded to your dev deployment.
 1. Your Convex dev deployment analyzes your code and finds all Convex functions.
    In this example, it determines that `tasks.getTaskList` is a new public query
    function.
@@ -114,6 +137,8 @@ applied and enforced on your backend.
 The [Convex dashboard](/docs/dashboard/deployments/deployments.md) will be a
 trusty helper throughout your dev, debug and deploy workflow in Convex.
 
+`npx convex dashboard` will open a link to the dashboard for your deployment.
+
 ### Logs
 
 Since Convex functions are TypeScript functions you can always use the standard
@@ -139,13 +164,16 @@ There is a lot more to to the dashboard. Be sure to click around or
 
 ## Deploying your app
 
-So far you've been working on your app against your personal dev deployment for
-the current project.
+So far you've been working on your app against your personal dev deployment.
+
+All Convex projects have one production deployment running in the cloud. It has
+separate data and has a separate push process from personal dev deployments,
+which allows you and your teammates to work on new features using personal dev
+deployments without disrupting your app running in production.
 
-All projects have one production deployment. It has separate data and has a
-separate push process from personal dev deployments, which allows you and your
-teammates to work on new features using personal dev deployments without
-disrupting your app running in production.
+If you have not created a Convex account yet, you will need to do so with
+`npx convex login`. This will automatically link any projects you've started
+with your new account, and enable using your production deployment.
 
 To push your code to your production deployment for your project you run the
 deploy command: