@aws/nx-plugin-mcp 1.0.0-rc.98 → 1.0.1

package/bin/aws-nx-mcp.js

@@ -21942,14 +21942,14 @@ const NX_VERSION = {
 	"@middy/core": "7.9.2",
 	"@nxlv/python": "23.0.0",
 	"@nx-extend/terraform": "10.4.1",
-	nx: "23.2.0",
-	"@nx/devkit": "23.2.0",
-	"@nx/js": "23.2.0",
-	"@nx/react": "23.2.0",
-	"@nx/vite": "23.2.0",
-	"@nx/vitest": "23.2.0",
-	"@nx/workspace": "23.2.0",
-	"create-nx-workspace": "23.2.0",
+	nx: "23.2.1",
+	"@nx/devkit": "23.2.1",
+	"@nx/js": "23.2.1",
+	"@nx/react": "23.2.1",
+	"@nx/vite": "23.2.1",
+	"@nx/vitest": "23.2.1",
+	"@nx/workspace": "23.2.1",
+	"create-nx-workspace": "23.2.1",
 	"@swc-node/register": "1.12.1",
 	"@swc/core": "1.16.1",
 	"@modelcontextprotocol/sdk": "1.30.0",
@@ -54646,6 +54646,7 @@ const renderComponent = (node, opts, pm, deps) => {
 			if (!commands) return void 0;
 			return [codeBlock(commands.map((c) => buildPackageManagerExecCommand(pm, c)).join("\n"))];
 		}
+		case "ArchitectureDiagram": return [];
 		default: return;
 	}
 };
@@ -54694,7 +54695,7 @@ const filterableValuesForProperty = (prop) => {
 /**
 * Pull out every filterable property (enum or boolean valued) as a
 * `FilterableOption`. Shared between the MCP server (deriving options from a
-* generator's schema) and the docs filter bar (mapping user-referenced keys
+* generator's schema) and the docs site (mapping user-referenced keys
 * onto their values).
 */
 const filterableOptionsFromSchema = (schema) => {
@@ -55424,6 +55425,13 @@ const generatorsJsonEntries = {
 		"metric": "g15",
 		"hidden": true
 	},
+	"open-api#py-client": {
+		"factory": "./src/open-api/py-client/generator",
+		"schema": "./src/open-api/py-client/schema.json",
+		"description": "Generate a Python httpx client from an OpenAPI specification",
+		"metric": "g73",
+		"hidden": true
+	},
 	"open-api#ts-client": {
 		"factory": "./src/open-api/ts-client/generator",
 		"schema": "./src/open-api/ts-client/schema.json",

package/docs/get_started/building-with-ai.mdx

@@ -6,14 +6,23 @@ description: Building with AI and the Nx Plugin for AWS MCP Server
 import Link from "@components/link.astro";
 import Snippet from "@components/snippet.astro";
 import { Steps, Tabs, TabItem } from "@astrojs/starlight/components";
+import Prompt from "@components/prompt.astro";
 
-Install the [Claude Plugin](https://code.claude.com/docs/en/plugins), [Kiro Power](https://kiro.dev/docs/powers/), or [MCP Server](https://modelcontextprotocol.io/introduction) to enable AI assistants to work effectively with the plugin. By using these, you can accelerate your development workflow with AI while benefitting from your projects being scaffolded in a consistent fashion, spending less time on setting up the main components and benefitting from the security, observability, type-safety and local development built into the plugin.
+## Already configured in your workspace
 
-## Configure your AI Assistant
+Workspaces created with the Nx Plugin for AWS preset include project-level MCP configuration for common coding agents — Claude Code, Cursor, Kiro, Gemini CLI, GitHub Copilot and OpenAI Codex — so an agent working inside the workspace can use the plugin's [MCP server](https://modelcontextprotocol.io/introduction) with no further setup.
 
-:::tip[Project-level configuration is automatic]
-Workspaces created with the Nx Plugin for AWS preset already include project-level MCP configuration for common coding agents (Claude Code, Cursor, Kiro, Gemini CLI, GitHub Copilot and OpenAI Codex). Any agent working inside the workspace can use the MCP server without further setup. The steps below configure the MCP server globally for use across all of your projects.
-:::
+Open your workspace in your assistant and ask it for what you want:
+
+<Prompt>
+Add a React website with an AG-UI agent, an MCP server for its tools and a DynamoDB table, and wire them together.
+</Prompt>
+
+It looks up the generators the plugin offers, runs them in the order their dependencies need. Use your agent to fill in the business logic from there.
+
+## Install globally
+
+The workspace configuration above is enough to build with. You can install globally if you'd like to use AI to create new workspaces, or <Link path="get_started/existing-project">add the Nx Plugin for AWS to an existing project</Link>:
 
 <Tabs syncKey="ai-assistant">
   <TabItem label="Kiro">
@@ -101,16 +110,14 @@ Workspaces created with the Nx Plugin for AWS preset already include project-lev
 
 ## Start Vibe Coding
 
-Ask your AI Assistant to build something using the `nx-plugin-for-aws`! It will typically create a workspace, scaffold with the applicable generators, then fill in the business logic.
+With the plugin available globally, your assistant can create the workspace too. Try a prompt like:
 
-Try a prompt like:
-
-> _"Build a multi-agent application using the Nx Plugin for AWS. I want a React frontend that talks to a backend orchestrator agent which delegates to specialised research and writing agents."_
+<Prompt>
+Build a multi-agent application using the Nx Plugin for AWS. I want a React frontend that talks to a backend orchestrator agent which delegates to specialised research and writing agents.
+</Prompt>
 
 Or for a smaller starting point:
 
-> _"Use the Nx Plugin for AWS to scaffold a React website backed by a tRPC API, with Cognito auth and CDK infrastructure."_
-
-## Build your own MCP Server
-
-Check out the <Link path="/guides/ts-mcp-server">`ts#mcp-server` generator guide</Link> for details about building your own MCP Server.
+<Prompt>
+Use the Nx Plugin for AWS to scaffold a React website backed by a tRPC API, with Cognito auth and CDK infrastructure.
+</Prompt>

package/docs/get_started/concepts.mdx

@@ -50,7 +50,7 @@ In practice:
 - **Upgrading is automated, not a re-adoption exercise.** A workspace generated months ago can move forward with the plugin rather than drifting further from it.
 - **Customisations are pattern-matched, not overwritten.** Migrations check that a file still matches the shape the generator produced. Where it has diverged beyond what they can safely update, they leave your code alone and report the manual follow-up instead.
 - **Some changes arrive as agent prompts.** Where the right edit depends on what you've built, the migration is a prompt your AI coding agent applies rather than a codemod.
-- **Upgrades are opt-in.** Nothing in your workspace changes until you choose to run `nx migrate`.
+- **Upgrades are opt-in.** Nothing in your workspace changes until you choose to run `nx migrate`. After running, you drop any changes you'd rather not take before you commit.
 
 Migrations narrow the gap rather than close it: how far your code has moved decides how much they can do, and some steps will still need your hands.
 

package/docs/get_started/existing-project.mdx

@@ -10,13 +10,16 @@ import NxCommands from '@components/nx-commands.astro';
 import NxInitCommand from '@components/nx-init-command.astro';
 import TsConfigBaseCompilerOptions from '@components/tsconfig-base-compiler-options.astro';
 import GeneratorParameters from '@components/generator-parameters.astro';
+import Prompt from '@components/prompt.astro';
 
 Not every project starts with `pnpm create @aws/nx-workspace`. If you already have an [Nx workspace](https://nx.dev) — or a monorepo you can add Nx to — you can adopt `@aws/nx-plugin` incrementally without recreating your project.
 
-<Aside type="tip">
-You can use your agentic coding tool of choice to add the plugin for you, using the <Link path="get_started/building-with-ai">MCP server</Link>. Try the prompt:
+<Aside type="tip" title="Use your coding agent">
+Your agentic coding tool of choice can add the plugin for you, using the <Link path="get_started/building-with-ai">MCP server</Link>. Try the prompt:
 
-> Add the Nx Plugin for AWS to this project.
+<Prompt>
+Add the Nx Plugin for AWS to this project.
+</Prompt>
 </Aside>
 
 ## Prerequisites
@@ -40,7 +43,7 @@ pnpm only runs install scripts for allow-listed packages, and `nx` needs its ins
 
 ```yaml title="pnpm-workspace.yaml"
 allowBuilds:
-  - nx
+  nx: true
 ```
 </Aside>
 

package/docs/get_started/quick-start.mdx

@@ -13,96 +13,99 @@ import RunGenerator from '@components/run-generator.astro';
 import NxCommands from '@components/nx-commands.astro';
 import Infrastructure from '@components/infrastructure.astro';
 import EmbeddedGraph from '@components/embedded-graph.astro';
+import Prompt from '@components/prompt.astro';
 
 This guide walks you through the basics of installing and using `@aws/nx-plugin` to rapidly build projects on AWS.
 
-:::tip[Full-Stack Tutorial]
-For a more in-depth tutorial for building a full-stack application, check out the <Link path="get_started/tutorials/dungeon-game/overview">Dungeon Adventure Tutorial</Link>.
-:::
-
 ## Prerequisites
 
 The following global dependencies are needed before proceeding:
 
 <Snippet name="prerequisites" />
 
-## Step 1: Initialize a New Nx Workspace
+## Step 1: Create a Workspace
 
-Run the following command to create an <Link path="guides/workspace">Nx workspace</Link> with the package manager of your choice:
+Create an <Link path="guides/workspace">Nx workspace</Link> with the package manager of your choice, and open the directory it creates:
 
-<CreateNxWorkspaceCommand workspace="my-project" />
+<CreateNxWorkspaceCommand workspace="my-project" readonly editable={['iac', 'containers']} />
 
-:::tip[Choosing an IaC Provider]
-You will be prompted for your preferred infrastructure as code (IaC) provider, either [CDK](https://docs.aws.amazon.com/cdk/) or [Terraform](https://developer.hashicorp.com/terraform). You can skip the prompt by running the command with `--iac`, ie:
+```sh
+cd my-project
+```
 
-<Infrastructure>
-<Fragment slot="cdk">
-<CreateNxWorkspaceCommand workspace="my-project" iac="cdk" />
-</Fragment>
-<Fragment slot="terraform">
-<CreateNxWorkspaceCommand workspace="my-project" iac="terraform" />
-</Fragment>
-</Infrastructure>
+You are prompted to choose your infrastructure as code provider, either [CDK](https://docs.aws.amazon.com/cdk/) or [Terraform](https://developer.hashicorp.com/terraform).
 
-You are also prompted for the container engine used by generators which build container images. Accept the default (`infer`) to select Docker if it is installed, otherwise Finch.
-:::
+## Step 2: Build Your Application
 
-Once complete, navigate to the project directory:
+We'll build a full-stack application: a tRPC API, a React website, Cognito authentication, and CDK or Terraform infrastructure. Ask an AI assistant to scaffold it for you, or run the generators yourself — both routes reach the same workspace.
 
-```sh
-cd my-project
-```
+### With AI
 
-## Step 2: Use Generators to Scaffold your Project
+<Steps>
+1. Open the workspace in your AI coding assistant.
 
-We'll add a tRPC API, React Website, Cognito Authentication, and CDK or Terraform Infrastructure in this quick-start guide. Depending on the type of project you're building, you can choose any combination of generators to quickly bootstrap your project. Check out the __Generators__ in the navigation bar to the left to see the full list of options, or try the <Link path="get_started/graph-builder">graph builder</Link> to construct your workspace visually.
+    New workspaces come with the plugin's <Link path="get_started/building-with-ai">MCP server</Link> already configured for Kiro, Claude Code, Cursor, Gemini CLI, GitHub Copilot and OpenAI Codex, so your assistant can look up the plugin's generators and run them without any setup.
 
-As a shortcut, you can use the button below to copy the commands to scaffold the full application.
+2. Ask for the application:
 
-<EmbeddedGraph preset="quick-start" workspace="my-project" iac="cdk" orientation="horizontal" skipWorkspace />
+    <Prompt>
+    Create a tRPC API called demo-api, and a React website called demo-website. Add Cognito authentication to the website, connect the website to the API, and add an infrastructure project called infra. Then instantiate the generated infrastructure components so the website and API deploy, granting authenticated users access to the API.
+    </Prompt>
 
-:::tip[Build with AI]
-The <Link path="get_started/building-with-ai">Nx Plugin for AWS MCP Server</Link> is already configured in your workspace, so you can ask your favourite AI coding agent like Kiro or Claude to build these projects for you instead of typing the CLI commands yourself.
-:::
+    Your assistant discovers the generators through the MCP server and runs them, in the order their dependencies need. Review the changes it makes, then carry on at Step 3.
+</Steps>
+
+### With the CLI
 
-Otherwise, follow the steps below to run each generator yourself.
+Run the generators that scaffold the application. Use the button below to copy them all, or run each one yourself as described beneath the diagram.
 
-### Add a tRPC API
+<Infrastructure>
+<Fragment slot="cdk">
+<EmbeddedGraph preset="quick-start" workspace="my-project" iac="cdk" orientation="horizontal" skipWorkspace />
+</Fragment>
+<Fragment slot="terraform">
+<EmbeddedGraph preset="quick-start" workspace="my-project" iac="terraform" orientation="horizontal" skipWorkspace />
+</Fragment>
+</Infrastructure>
 
-<RunGenerator generator="ts#api" requiredParameters={{ name: 'demo-api', framework: 'trpc', auth: 'iam' }} noInteractive />
+Depending on the type of project you're building, you can choose any combination of generators to quickly bootstrap your project. Check out the __Generators__ in the navigation bar to the left to see the full list of options, or try the <Link path="get_started/graph-builder">graph builder</Link> to construct your workspace visually.
+
+#### Add a tRPC API
+
+<RunGenerator generator="ts#api" requiredParameters={{ name: 'demo-api', framework: 'trpc' }} positional={['name']} noInteractive readonly />
 
 This will create the API inside the `packages/demo-api` folder.
 
-### Add a React Website
+#### Add a React Website
 
-<RunGenerator generator="ts#website" requiredParameters={{ name: 'demo-website' }} noInteractive />
+<RunGenerator generator="ts#website" requiredParameters={{ name: 'demo-website' }} positional={['name']} noInteractive readonly />
 
 This scaffolds a new React website in `packages/demo-website`.
 
-### Add Cognito Authentication
+#### Add Cognito Authentication
 
-<RunGenerator generator="ts#website#auth" requiredParameters={{ project: '@my-project/demo-website', cognitoDomain: 'my-demo' }} noInteractive />
+<RunGenerator generator="ts#website#auth" requiredParameters={{ project: 'demo-website' }} noInteractive readonly />
 
 This sets up the necessary infrastructure and React code to add Cognito Authentication to your website.
 
-### Connect Frontend to Backend
+#### Connect Frontend to Backend
 
-<RunGenerator generator="connection" requiredParameters={{ sourceProject: '@my-project/demo-website', targetProject: '@my-project/demo-api' }} noInteractive />
+<RunGenerator generator="connection" requiredParameters={{ sourceProject: 'demo-website', targetProject: 'demo-api' }} noInteractive readonly />
 
 This configures the necessary providers to ensure your website can call your tRPC API.
 
-### Add Infrastructure
+#### Add Infrastructure
 
 Add the infrastructure project based on your chosen IAC provider.
 
 <Infrastructure>
 <Fragment slot="cdk">
-<RunGenerator generator="ts#infra" requiredParameters={{ name: 'infra' }} noInteractive />
+<RunGenerator generator="ts#infra" requiredParameters={{ name: 'infra' }} positional={['name']} noInteractive readonly />
 
 This configures a CDK App which you can use to deploy your infrastructure on AWS.
 </Fragment>
 <Fragment slot="terraform">
-<RunGenerator generator="terraform#project" requiredParameters={{ name: 'infra' }} noInteractive />
+<RunGenerator generator="terraform#project" requiredParameters={{ name: 'infra' }} positional={['name']} noInteractive readonly />
 
 This configures a Terraform project which you can use to deploy your infrastructure on AWS.
 </Fragment>
@@ -118,18 +121,64 @@ Your website will be available at `http://localhost:4200`.
 
 Changes to both your website and API will be reflected in real-time as both the local website and API servers will hot-reload.
 
+<Drawer title="Calling your API from your website" trigger="Try it: call the API from your website">
+
+Connecting the website to the API added a `useDemoApi` hook, which returns a [tRPC options proxy](https://trpc.io/docs/client/tanstack-react-query): every procedure on your API offers `queryOptions` and `mutationOptions` to hand to [TanStack Query](https://tanstack.com/query/latest).
+
+Update `packages/demo-website/src/routes/index.tsx` to call the API's `echo` procedure, showing a spinner while the request is in flight:
+
+```diff lang="tsx"
++import { useQuery } from '@tanstack/react-query';
+import { createFileRoute } from '@tanstack/react-router';
++import { Spinner } from '../components/spinner';
++import { useDemoApi } from '../hooks/useDemoApi';
+
+export const Route = createFileRoute('/')({
+  component: RouteComponent,
+});
+
+function RouteComponent() {
++  const trpc = useDemoApi();
++  const echo = useQuery(
++    trpc.echo.queryOptions({ message: 'Hello from the API!' }),
++  );
++
+  return (
+    <div className="text-center">
+      <header>
+        <h1>Welcome</h1>
+        <p>Welcome to your new React website!</p>
+      </header>
++      {echo.isLoading ? (
++        <Spinner />
++      ) : echo.error ? (
++        <p>Error: {echo.error.message}</p>
++      ) : (
++        <p>{echo.data?.message}</p>
++      )}
+    </div>
+  );
+}
+```
+
+Save the file and the page reloads with the message your API echoed back. The call is type-safe end to end — rename `message` in `packages/demo-api/src/schema/echo.ts` and your website stops compiling until you follow the change through.
+
+See the <Link path="guides/connection/react-trpc">React to tRPC connection guide</Link> for mutations, subscriptions, error handling and optimistic updates.
+
+</Drawer>
+
 ## Step 4: Define Cloud Resources and Deploy to AWS
 
 <Infrastructure>
 <Fragment slot="cdk">
 Open `packages/infra/src/stacks/application-stack.ts` and add the following code:
 
-```typescript
-import {
-  DemoApi,
-  DemoWebsite,
-  UserIdentity,
-} from '@my-project/common-constructs';
+```diff lang="ts"
++import {
++  DemoApi,
++  DemoWebsite,
++  UserIdentity,
++} from '@my-project/common-constructs';
 import { Stack, StackProps } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 
@@ -137,13 +186,13 @@ export class ApplicationStack extends Stack {
   constructor(scope: Construct, id: string, props?: StackProps) {
     super(scope, id, props);
 
-    const identity = new UserIdentity(this, 'identity');
-    const api = new DemoApi(this, 'api', {
-      integrations: DemoApi.defaultIntegrations(this).build(),
-    });
-    api.grantInvokeAccess(identity.identityPool.authenticatedRole);
-
-    new DemoWebsite(this, 'website');
++    const identity = new UserIdentity(this, 'identity');
++    const api = new DemoApi(this, 'api', {
++      integrations: DemoApi.defaultIntegrations(this).build(),
++    });
++    api.grantInvokeAccess(identity.identityPool.authenticatedRole);
++
++    new DemoWebsite(this, 'website');
   }
 }
 ```
@@ -154,11 +203,6 @@ This is all the CDK we need to write to deploy our full stack application.
 Open `packages/infra/src/main.tf` and add the following code:
 
 ```hcl
-# Include metrics tracking for @aws/nx-plugin usage
-module "metrics" {
-  source = "../../common/terraform/src/metrics"
-}
-
 # Deploy user identity
 module "user_identity" {
   source = "../../common/terraform/src/core/user-identity"
@@ -213,6 +257,15 @@ module "demo_website" {
 
   depends_on = [module.user_identity, module.demo_api]
 }
+
+# Print the website URL and user pool id when the deployment finishes
+output "website_url" {
+  value = module.demo_website.website_url
+}
+
+output "user_pool_id" {
+  value = module.user_identity.user_pool_id
+}
 ```
 
 This is all the Terraform we need to write to deploy our full stack application.
@@ -231,7 +284,7 @@ If you encounter any lint or formatting errors, you can run the following comman
 <PackageManagerShortCommand commands={["lint"]} />
 :::
 
-:::tip[The workspace is out of sync]
+:::note[The workspace is out of sync]
 If the build reports `The workspace is out of sync`, accept the prompt to sync the workspace or run the following sync command directly before retrying the build:
 
 <NxCommands commands={["sync"]} />
@@ -246,7 +299,9 @@ Bootstrap your infrastructure:
 <NxCommands commands={['bootstrap infra']} />
 
 :::tip[Bootstrap Regions]
-CDK bootstrapping is required for both your target deployment AWS region, and `us-east-1` to allow deployment of the AWS WAF WebACL for the website.
+CDK bootstrapping is required for both your target deployment AWS region, and `us-east-1` to allow deployment of the AWS WAF WebACL for the website. If you are deploying elsewhere, bootstrap `us-east-1` too:
+
+<NxCommands commands={['run infra:bootstrap --args="aws://<account-id>/us-east-1"']} />
 :::
 </Fragment>
 <Fragment slot="terraform">
@@ -308,6 +363,8 @@ The first time you sign in as this user you are prompted to choose a new passwor
 
 Your website is also served from CloudFront. Open its distribution domain name (which is printed to your terminal after deployment) to use the version running entirely on AWS.
 
+Congratulations! 🎉 You have successfully built and deployed a full-stack application using `@aws/nx-plugin`!
+
 ## Step 6: Clean Up
 
 When you have finished, delete the resources you deployed to avoid ongoing costs:
@@ -315,16 +372,47 @@ When you have finished, delete the resources you deployed to avoid ongoing costs
 <Infrastructure>
 <Fragment slot="cdk">
 <NxCommands commands={['destroy-sandbox infra']} />
+
+:::note[Retained Resources]
+The Cognito user pool is created with deletion protection enabled, so it is not removed automatically. Delete it (and the IAM role Cognito uses to send SMS messages) manually if you no longer need them.
+:::
 </Fragment>
 <Fragment slot="terraform">
 <NxCommands commands={['destroy infra']} />
+
+:::note[Retained Resources]
+The Cognito user pool is created with deletion protection enabled, so it is not removed automatically (the destroy command will report a failure). Delete it (and the IAM role Cognito uses to send SMS messages) manually if you no longer need them.
+:::
 </Fragment>
 </Infrastructure>
 
-:::note[Retained Resources]
-The Cognito user pool is created with deletion protection enabled, so it is not removed automatically. Delete it (and the IAM role Cognito uses to send SMS messages) manually if you no longer need them.
+To remove bootstrap resources, follow below:
+
+<Infrastructure>
+<Fragment slot="cdk">
+Delete the bootstrap stack in every region you bootstrapped, including `us-east-1`. This removes the bootstrap roles and the container image repository:
+
+```sh
+aws cloudformation delete-stack --stack-name CDKToolkit --region <region>
+```
+
+:::note[Asset Bucket]
+The asset bucket is retained on purpose, so delete it separately.
 :::
+</Fragment>
+<Fragment slot="terraform">
+<NxCommands commands={['bootstrap-destroy infra']} />
+
+:::caution[Your Terraform State Is Deleted Too]
+This empties and deletes the S3 bucket holding your Terraform state, so only run it once you have torn down all deployed infrastructure.
+:::
+</Fragment>
+</Infrastructure>
 
 ---
 
-Congratulations! 🎉 You have successfully built and deployed a full-stack application using `@aws/nx-plugin`!
+## Next Steps
+
+- <Link path="get_started/tutorials/dungeon-game/overview">Dungeon Adventure Tutorial</Link> — build a full-stack AI dungeon adventure game, for a more in-depth walkthrough than this guide.
+- <Link path="guides/workspace">Workspaces</Link> — how your workspace is laid out, and the configuration the generators share.
+- <Link path="get_started/existing-project">Add to an Existing Project</Link> — adopt the plugin in your existing codebase.

package/docs/get_started/tutorials/contribute-generator.mdx

@@ -54,7 +54,7 @@ Let's create the new generator in `packages/nx-plugin/src/trpc/procedure`.
 
 We provide a generator for creating new generators so you can quickly scaffold your new generator! You can run this generator as follows:
 
-<RunGenerator generator="ts#nx-generator" requiredParameters={{ project: '@aws/nx-plugin', name: 'ts#trpc-api#procedure', directory: 'trpc/procedure', description: 'Adds a procedure to a tRPC API' }} />
+<RunGenerator generator="ts#nx-generator" requiredParameters={{ project: '@aws/nx-plugin', name: 'ts#trpc-api#procedure', directory: 'trpc/procedure', description: 'Adds a procedure to a tRPC API' }} readonly />
 
 You will notice the following files have been generated for you:
 
@@ -313,11 +313,11 @@ If you have completed the <Link path="get_started/tutorials/dungeon-game/overvie
 
 In a separate directory, create a new test workspace:
 
-<CreateNxWorkspaceCommand workspace="trpc-generator-test" />
+<CreateNxWorkspaceCommand workspace="trpc-generator-test" readonly />
 
 Next, let's generate a tRPC API to add the procedure to:
 
-<RunGenerator generator="ts#api" requiredParameters={{name:"test-api", framework:"trpc"}} noInteractive />
+<RunGenerator generator="ts#api" requiredParameters={{name:"test-api", framework:"trpc"}} noInteractive readonly />
 
 #### Link our local Nx Plugin for AWS
 
@@ -337,7 +337,7 @@ Notice above we linked to the compiled plugin in `dist/packages/nx-plugin` rathe
 
 Let's try the new generator:
 
-<RunGenerator generator="ts#trpc-api#procedure" />
+<RunGenerator generator="ts#trpc-api#procedure" readonly />
 
 :::note[Generator Not Showing]
 If you don't see the new generator in the list in VSCode, you might need to refresh the Nx workspace:
@@ -397,7 +397,7 @@ In practice, this process might look like:
 
 1. Create a new workspace
 
-    <CreateNxWorkspaceCommand workspace="my-project" />
+    <CreateNxWorkspaceCommand workspace="my-project" readonly />
   
 1. Run any generators that may be prerequisites to your new generator/feature/fix
 1. Commit your changes (`git commit`)