agentleFS
MicrosoftKnown publishermicrosoft/sqlhyperscalemechanics/.github/skills/start-and-grow-hyperscale-demo/SKILL.md

start-and-grow-hyperscale-demo

Skill0 starsChanged 8 days agoMITView on GitHub

Deploy, populate, verify, and operate Caldova Patient Access on Azure SQL Database Hyperscale. Use for "Help me deploy a database for Caldova Patient Access", "Populate the database we just deployed with the demo schema and data", "Prepare the resource group and Start logical server", "Reset Scene 2 for a fresh deployment", "Create the pool on the Start server", pool-only deployment, Caldova sizing or resource reuse, integrating acquired providers, adding or removing provider databases from the elastic pool, pool scaling, measured storage growth, native cross-database queries, or restoring Caldova serverless. Requires explicit approval for Azure changes.

The file

Show its rules and text

We split this skill into the rules it gives an agent

51 rules. About 0 are common, 35 are distinctive, and 16 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈35

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 16

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Use actual Azure management responses, SQL results, and application measurements.

    line 9
  2. Distinctive:

    Keep deployment, database population, compute changes, and data resets separate.

    line 10
  3. Very specific:

    Never delete either logical SQL server or the shared resource group.

    line 14
  4. Distinctive:

    Use the currently signed-in Azure CLI user and subscription after read-only verification.

    line 17
  5. Distinctive:

    Use supplied qualitative requirements.

    line 26
  6. Distinctive:

    Do not open questionnaires or confirmation forms.

    line 30
  7. Distinctive:

    Keep Entra-only authentication and least privilege.

    line 34
  8. Distinctive:

    If an operation fails, inspect partial completion before rerunning.

    line 40
  9. Distinctive:

    Never silently replay an uncertain write.

    line 42
  10. Distinctive:

    Default targets, subject to configuration and live verification:

    line 53
  11. Distinctive:

    Start and Grow can remain provisioned independently.

    line 85
  12. Distinctive:

    Verify the current CLI account and signed-in Entra user internally.

    line 100
  13. Distinctive:

    Verify current supported configuration and platform limits against Microsoft Learn.

    line 103
  14. Distinctive:

    If the named server or resource group is missing, stop and propose the separate preparation workflow below.

    line 109
  15. Very specific:

    Keep subscription identifiers out of displayed output.

    line 118
  16. Very specific:

    Never use 04-deploy-sql.ps1 for Start.

    line 121
  17. Very specific:

    Wait for approval, then run the same command without -WhatIf.

    line 122
  18. Very specific:

    If caldova-scheduling exists, the script verifies instead of recreating it.

    line 123
  19. Distinctive:

    Do not call reuse a new deployment, delete the existing database, or change mismatched settings without separate approval.

    line 124
  20. Very specific:

    No database, firewall rule, schema, app, or pool changes are included.

    line 145
  21. Very specific:

    Use the MSSQL extension with the verified Entra deployment identity to execute that SQL file only on Start caldova-scheduling, without USE.

    line 160
  22. Very specific:

    Verify the connected server/database and all three tables.

    line 164
  23. Distinctive:

    Verify reachability before opening a standalone Edge window, not the integrated VS Code browser.

    line 185
  24. Distinctive:

    Start explicitly. Matching names on Grow are separate resources, not substitutes.

    line 204
  25. Distinctive:

    Verify the current CLI subscription/user, existing Start server, Entra-only authentication, TLS 1.2, and existing Allow Azure services …

    line 210
  26. Distinctive:

    Never switch subscriptions, discover client IPs, add firewall rules, enable previews, or create missing prerequisite databases as part of …

    line 212
  27. Distinctive:

    All three databases must already exist with compatible Hyperscale, local-backup, non-zone-redundant settings and no membership in another …

    line 214
  28. Distinctive:

    Verify supported Hyperscale pool capacity/limits against Microsoft Learn and current Azure capabilities.

    line 216
  29. Very specific:

    After approval, run the same command without -WhatIf, synchronously.

    line 231
  30. Distinctive:

    After an uncertain failure, inspect partial state before any new submission.

    line 235
  31. Distinctive:

    Use only the membership script:

    line 249
  32. Very specific:

    Use -Mode Standalone -WhatIf for removal, retaining the same target/server.

    line 258
  33. Distinctive:

    Pooled: all three databases on the approved server join its existing pool.

    line 267
  34. Distinctive:

    Verify current values in configuration.

    line 271
  35. Very specific:

    Keep the synchronous command running until it completes or the user stops it.

    line 285
  36. Very specific:

    After a tool timeout, read the same shell.

    line 286
  37. Distinctive:

    Before continuing, inspect all three on the exact approved server.

    line 297
  38. Distinctive:

    Keep data, bookings, objects, identities, both servers, and the pool.

    line 304
  39. Distinctive:

    Verify every database is Online in the requested placement before resuming SQL.

    line 305
  40. Distinctive:

    Only then report complete, listing all three names and states.

    line 306
  41. Distinctive:

    Verify capacity support, quotas, redundancy, CLI/API syntax, and limits.

    line 313
  42. Very specific:

    Read the view and permissions.

    line 339
  43. Very specific:

    Use the approved 07-deploy-scheduling.ps1 Network phase for setup.

    line 341
  44. Very specific:

    Keep the provider-keyed LEFT JOIN view, Caldova source connection, parameterized allowlisted provider writes, and conditional …

    line 345
  45. Distinctive:

    No external-table substitution, multi-database write transaction, extra audit write, SQL password, broad role, or uncertain-write replay.

    line 348
  46. Distinctive:

    Never invoke it autonomously or treat a failed/unknown outcome as success.

    line 355
  47. Distinctive:

    Never infer deletion, reseeding, booking changes, storage shrink, or compute restoration from an unqualified "reset".

    line 359
  48. Very specific:

    Wait for exact deletion approval, then run without -WhatIf.

    line 371
  49. Distinctive:

    Do not redeploy or populate automatically.

    line 373
  50. Distinctive:

    Run the smallest relevant offline checks:

    line 383
  51. Distinctive:

    Never claim locally edited source has already been published.

    line 405

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Start and Grow Hyperscale

Deploy and operate Azure SQL Database Hyperscale for Caldova Patient Access. Use actual Azure management responses, SQL results, and application measurements. Keep deployment, database population, compute changes, and data resets separate.

Safety and interaction

  • Never delete either logical SQL server or the shared resource group. Preserve server-level cross-database preview settings and the existing pool. 99-remove.ps1 is disabled; never use resource-group deletion for a reset.
  • Use the currently signed-in Azure CLI user and subscription after read-only verification. Do not sign in again, silently switch subscriptions, or ask the user to select an already supplied target again. Stop on configuration conflicts.
  • Identify resources by subscription display name, resource group, server, pool, and database names. Do not display subscription IDs, tenant IDs, tokens, or full Azure resource IDs. Redact those identifiers from plans and errors.
  • Present one recommended plan with explicit assumptions. For deployment, keep the recommendation and rationale within 60 words, followed by at most four short change bullets and one approval line. Expand only when requested.
  • Use supplied qualitative requirements; do not request numerical usage or cost estimates for the pilot. Do not invent sizing guarantees or price estimates.
  • Show exact proposed changes and wait for typed approval before execution. "Next" is not approval. Approval applies only to the named operation. Do not open questionnaires or confirmation forms.
  • This environment uses Allow Azure services. Include it in the approved connection plan; retain existing rules. Do not discover a client IP or create a PresenterClient rule. This is not a production networking recommendation.
  • Keep Entra-only authentication and least privilege. Firewall expansion, grants, redundancy changes, and publishing require their own approved scope.
  • SQL connections can resume serverless compute, incur charges, and restart the idle period. Disclose that before connecting to a paused database.
  • Report source, local tests, deployment, ARM state, SQL permissions, and application readiness separately. HTTP 200 does not establish SQL readiness.
  • If an operation fails, inspect partial completion before rerunning. Surface errors explicitly; never infer absence from an authorization/read error. Never silently replay an uncertain write.

Sources and targets

Commands are relative to the repository root. Read configuration and the relevant implementation before issuing commands. Consult the corresponding setup and measured-evidence sections in the README as needed. Historical evidence is not current Azure state.

Default targets, subject to configuration and live verification:

PurposeLogical serverDatabase or pool
Start<start-server>caldova-scheduling
Start pool rehearsal<start-server>caldova-network-pool; existing northbrook-scheduling, ridgeview-scheduling
Grow<network-server>caldova-scheduling, northbrook-scheduling, ridgeview-scheduling
Grow pool<network-server>caldova-network-pool

Public files never contain the live server or app names. <start-server>, <network-server>, and <network-app> stand for sql-caldova-start-<suffix>, sql-caldova-network-<suffix>, and app-caldova-network-<suffix>. 00-config.ps1 derives <suffix> from the current subscription unless CALDOVA_PART1_SQL_SERVER, CALDOVA_NETWORK_SQL_SERVER, or CALDOVA_NETWORK_APP_NAME override the names. Before planning, resolve the servers read-only in the resource group by name prefix:

az sql server list --resource-group caldova-network-rg --query "[?starts_with(name, 'sql-caldova-')].{name:name, location:location}" --output table

Expect exactly one sql-caldova-start-* and one sql-caldova-network-* server, and confirm each matches the name 00-config.ps1 computes ($Part1SqlServerName, $SqlServerName). If none, several, or mismatched names are found, stop and explain the conflict; never guess or substitute one server for the other. Use the resolved names in plans and -ExpectedServerName arguments. The local app reads the same names from git-ignored startandgrowhyperscale/app/appsettings.Local.json; see the README section "Private local configuration".

Both servers use caldova-network-rg. The same database name on two servers does not identify the same database. Start deployment must not alter Grow. Start and Grow can remain provisioned independently; deploying Start does not require removing Grow databases from the pool.

Requirements-led database deployment

Recognize this request without requiring a product recommendation in the prompt:

Help me deploy a database for Caldova Patient Access. Usage peaks in the morning, with nights and weekends idle. We need automatic compute scaling, low idle cost, and room to grow without sizing storage. A short wake-up delay is fine. Use the currently logged-in Azure user and subscription, resource group caldova-network-rg, and the existing Start server (sql-caldova-start-*) in it. Recommend a configuration, state assumptions, and show the plan for approval before deploying.

  1. Verify the current CLI account and signed-in Entra user internally. Inspect the resource group, Start server, region, security settings, and target database through management APIs, without opening SQL connections.
  2. Verify current supported configuration and platform limits against Microsoft Learn. Recommend Hyperscale for storage growth and serverless for intermittent activity and acceptable wake-up delay. For the supplied requirements, propose HS_S_Gen5_8, 1-8 vCores, and 60-minute auto-pause. Treat local backups, no zone redundancy, and Entra-only authentication as pilot assumptions. The vCore range is a starting point, not measured capacity assurance.
  3. If the named server or resource group is missing, stop and propose the separate preparation workflow below. Do not silently substitute the Grow server or create additional resources outside the approved plan.
  4. Preview the actual deployment:

    .\startandgrowhyperscale\deploy\09-deploy-part1-sql.ps1 -AllowAzureServices -WhatIf

    Keep subscription identifiers out of displayed output. Describe resources reused versus created, compute, auto-pause, security/connectivity, backup, and availability assumptions. Use -AllowAzureServices without -ClientIp. Never use 04-deploy-sql.ps1 for Start; it targets Grow resources.

  5. Wait for approval, then run the same command without -WhatIf. If caldova-scheduling exists, the script verifies instead of recreating it. Do not call reuse a new deployment, delete the existing database, or change mismatched settings without separate approval.
  6. Independently verify the exact server/database, status, Hyperscale serverless objective, minimum/maximum capacity, auto-pause, and approved security settings. Then provide a short verified summary and direct the user to the same database in Azure Portal. Population is a separate operation.

Prepare the Start server

For "Prepare the resource group and Start logical server", verify targets first:

.\startandgrowhyperscale\deploy\00-prepare-part1.ps1 -WhatIf

Show what will be reused or created and wait for approval before rerunning without -WhatIf. This creates only missing resources and verifies identity, region, TLS 1.2, public endpoint, and Entra-only authentication. The signed-in Entra user becomes administrator on a new server. Existing incompatible servers cause an error rather than silent changes.

No database, firewall rule, schema, app, or pool changes are included. Deployment separately approves the Allow Azure services setting. Do not use 04-deploy-sql.ps1 or 99-remove.ps1 for preparation.

Populate the deployed Start database

For "Populate the database we just deployed with the demo schema and data":

  1. Recover and verify the exact Start target from the deployment. Never infer it from the shared database name or redirect the multi-provider setup script.
  2. Read the schema. Preview creation of missing appointment/slot/provider-directory objects and insertion of synthetic future UTC slots and provider entries. No patient data, deletion, truncation, booking reset, compute change, or pool move. Explain SQL resume implications and obtain approval before connecting.
  3. Use the MSSQL extension with the verified Entra deployment identity to execute that SQL file only on Start caldova-scheduling, without USE. Do not run 07-deploy-scheduling.ps1 -Phase Schema, network-view setup, app-login creation, or multi-database permission scripts for this single-database step.
  4. Verify the connected server/database and all three tables. On a fresh database expect 50 unbooked future slots across five specialties, three provider keys (caldova, northbrook, ridgeview), and zero appointments. On reruns preserve bookings and existing rows; verify no duplicate seed keys. Inspect partial state on failure before rerunning.
  5. Disconnect setup/verification clients so they do not prevent auto-pause. Report actual counts; do not claim acquired-provider setup or cross-database access from population of Start.

Start app and serverless measurements

The app's part1 launch profile targets the separate Start server. Verify both the scheduling connection and monitor resource target before launching:

dotnet run --project .\startandgrowhyperscale\app\CaldovaNetworkScheduling.csproj --launch-profile part1

The profile enables real SQL workload generation. Do not run a workload, resume compute, or start observation without approval for the target and scope. Launching and HTTP reachability do not establish application SQL permissions. Verify reachability before opening a standalone Edge window, not the integrated VS Code browser.

CPU readings use sys.dm_db_resource_stats and each sample's own limit: avg_cpu_percent * cpu_limit / 100. Retain actual UTC timestamps and missing intervals; workers are not cores. VIEW DATABASE STATE may be required; never grant it automatically.

Billing comes from Azure Monitor, not SQL CPU readings. For average billed vCores use app_cpu_billed Sum divided by bucket seconds. Close all SQL clients before waiting for the configured idle interval. Verify pause via ARM status and activity, not SQL polling or absent metric bars. Do not promise CPU-only billing, zero downtime, fixed resume duration, or measured cache warm-up. The read-only first-sign-in path can retry transient resume failures; that exception never permits replaying bookings or pool-scaling writes.

Create the pool on Start (pool-only deployment)

For "Create the pool on the Start server" or a pool-creation rehearsal, target Start explicitly. Matching names on Grow are separate resources, not substitutes. The app remains connected to its existing targets; do not add environment UI or change app configuration for this deployment.

  1. Read configuration and the pool-only script. Verify the current CLI subscription/user, existing Start server, Entra-only authentication, TLS 1.2, and existing Allow Azure services through ARM only. Never switch subscriptions, discover client IPs, add firewall rules, enable previews, or create missing prerequisite databases as part of pool creation. All three databases must already exist with compatible Hyperscale, local-backup, non-zone-redundant settings and no membership in another pool.
  2. Verify supported Hyperscale pool capacity/limits against Microsoft Learn and current Azure capabilities. Recommend the configured baseline: an empty Hyperscale Gen5 pool, 8 total vCores, minimum 0 / maximum 8 per database, no zone redundancy. Local backups remain database settings, not a pool-create CLI parameter. Preserve server-level cross-database preview settings.
  3. Preview the exact target and plan:

    .\startandgrowhyperscale\deploy\14-create-part1-pool.ps1 -ExpectedServerName <start-server> -WhatIf

    Show subscription display name, resource group, server, pool, compute/caps, security retained, and exclusions. Ask for typed approval of pool creation only. Never run 04-deploy-sql.ps1 here: it deploys Grow resources and a client-IP firewall rule. Never repoint global Grow configuration to Start.

  4. After approval, run the same command without -WhatIf, synchronously. An existing compatible pool is verified and reused, not called newly created. Identity, tier, family, capacity, caps, readiness, or redundancy mismatches stop without updating/recreating it. Authorization/read errors are not absence. After an uncertain failure, inspect partial state before any new submission.
  5. Independently verify the exact Start pool is Ready, Hyperscale Gen5, 8 vCores, caps 0-8, no zone redundancy, and empty when newly created. Report ARM results separately from SQL/app readiness. No SQL connections, database moves, population, app publishing, or Grow changes are included. Keep the three databases and Caldova serverless unchanged.

The pool-only script does not add members. If the request says "empty pool" or "do not move databases", stop after pool verification; do not surprise the user with a membership approval. If membership is requested afterward, use the explicit Start target below, never the default Grow target.

Pool membership

Use only the membership script:

# Existing Grow workflow (default target preserved).
.\startandgrowhyperscale\deploy\06-set-pool-membership.ps1 -Mode Pooled -WhatIf
# Start recording/integration: pin this target explicitly.
.\startandgrowhyperscale\deploy\06-set-pool-membership.ps1 -Target Start -ExpectedServerName <start-server> -Mode Pooled -WhatIf

Use -Mode Standalone -WhatIf for removal, retaining the same target/server. Infer the target only from the explicit request or verified deployment in the same chat. If recording uses Start but subsequent app beats use the existing Grow pool, keep those contexts separate. Never redirect app settings or global Grow configuration to make a Start move work. Inspect all three current placements first, including interrupted operations. The pool must already exist and retain its preview enablement. Reject databases belonging to another pool. Do not recreate the pool or change preview settings.

  • Pooled: all three databases on the approved server join its existing pool; Caldova leaves serverless for provisioned Hyperscale compute.
  • Standalone: restore Caldova on that server to HS_S_Gen5_8, minimum 1 vCore, auto-pause 60 minutes; Northbrook to HS_Gen5_2; Ridgeview to HS_Gen5_4. Verify current values in configuration.

State actual compute, target server/pool, all three database names, and possible connection interruptions. Confirm dependent SQL traffic is stopped before applying. One typed approval can authorize the complete named membership plan, including Caldova conversion and all three moves. After that approval, invoke the exact previewed command without -WhatIf and with -Confirm:$false; do not ask separately for each database or stop after the first one. Pool creation approval alone is not membership approval. If a user explicitly requests both, show both stages and all changes together for approval; execute pool creation first and the separately targeted membership script second.

Interrupted moves and delayed Azure readiness

  • Keep the synchronous command running until it completes or the user stops it. After a tool timeout, read the same shell; never start another command for the same operation or use --no-wait. Report concise progress without declaring membership complete from an update response or one pooled database.
  • The script waits using ARM reads for conversion, pool removal, and each final configuration (up to 30 minutes per phase), then verifies all three databases. Delayed Scaling/Resuming states are observation, not permission to repeat an update. No SQL probes or write retries are used.
  • On an error, show the per-database partial state and error. If state cannot be read, report that explicitly; do not assume a database is absent or unchanged. Preserve completed moves/conversion and never roll back, recreate the pool, repopulate data, or grant permissions automatically.
  • Before continuing, inspect all three on the exact approved server. Wait for any in-flight operation to settle. Rerunning the same target/direction skips correct members and an already-completed Caldova conversion, finishing only remaining changes. An unchanged valid approval covers the same plan after state inspection, not a changed target/capacity or new operation. If the user explicitly stopped or moved on, do not resume until they request continuation.

Keep data, bookings, objects, identities, both servers, and the pool. Verify every database is Online in the requested placement before resuming SQL. Only then report complete, listing all three names and states. Otherwise report partial/incomplete. ARM membership alone does not establish native cross-database SQL readiness.

Pool scaling and storage growth

  • Inspect the existing Ready Hyperscale Gen5 pool and all three Online members. Verify capacity support, quotas, redundancy, CLI/API syntax, and limits.
  • Cap policy: minimum 0; maximum 12 per database at 24 pool vCores, maximum 8 at 8 pool vCores. Never exceed total pool capacity. Configuration defines the policy; existing mismatches need an approved update, not recreation.
  • The real /scale controls change 8/24 pool capacity and the corresponding per-database maximum, then verify both. These require localhost opt-in. Each user click authorizes its defined operation; never click during tests. Include cap changes in every assistant-submitted scale approval.
  • Approve bounded, cancellable real scheduling/CPU work separately. For scale-under-load validation, keep the approved work running through scaling. Record timestamps, successes, latency, errors, and recovery. ARM completion and application recovery are different evidence. Do not add write retries.
  • Actual storage reads use SQL data-file used/allocated measurements. Initial Grow fill targets are Caldova 18, Northbrook 12, Ridgeview 15 GiB used via 07-deploy-scheduling.ps1 -Phase Storage, or Schema with -IncludeStorageFill. Approve this large fill separately; never include it in Start population.
  • PoolGrowth__Enabled=true permits bounded Caldova inserts past 20 GiB, capped at 21 GiB used with a 22-GiB safety ceiling. Stop once SQL confirms both used and allocated space above 20 GiB. Keep growth disabled on public hosts. Committed data remains after Stop; reruns never reset or shrink it.
  • The bounded proof script is deploy\13-rehearse-pool-growth.ps1; inspect its configuration, preview with -WhatIf, and obtain exact approval before running. Neither its name nor a successful local test establishes measured growth.

Native search and booking

Read the view and permissions. Use the approved 07-deploy-scheduling.ps1 Network phase for setup; it changes SQL objects/grants and is not read-only preflight. Inspect partial setup before rerunning failures. Verify deployed application identity separately from setup identity.

Keep the provider-keyed LEFT JOIN view, Caldova source connection, parameterized allowlisted provider writes, and conditional single-provider booking transaction. Preserve membership/future/unbooked checks and concurrency protection. No external-table substitution, multi-database write transaction, extra audit write, SQL password, broad role, or uncertain-write replay.

Confirmed bookings remain visible as Booked until a fresh availability search excludes them. The opted-in localhost reset deletes only the exact confirmed appointment ID and reopens its provider slot in one transaction. Reset is disabled by default; each explicit click authorizes only that reset. Never invoke it autonomously or treat a failed/unknown outcome as success.

Explicit resets

Never infer deletion, reseeding, booking changes, storage shrink, or compute restoration from an unqualified "reset".

For "Reset Scene 2 for a fresh deployment", first stop dependent Start traffic and preview deletion of only the explicitly named Start database:

.\startandgrowhyperscale\deploy\10-reset-part1.ps1 -ExpectedServerName <start-server> -WhatIf

Explain loss of Start schema/data/bookings and preservation of both servers, resource group, all Grow databases, pool, app, and preview settings. Wait for exact deletion approval, then run without -WhatIf; -Confirm:$false is allowed only after approval. Verify absence independently. Do not redeploy or populate automatically.

Real Grow storage reset uses 12-reset-demo-storage.ps1 with a separate preview and approval. It restores only the approved storage payload baseline and must preserve scheduling data, other objects, memberships, and compute. Booking resets must identify the exact provider, slot, and appointment. Capacity restoration and standalone membership restoration are separate operations.

Validation and execution

Run the smallest relevant offline checks:

dotnet build .\startandgrowhyperscale\app\CaldovaNetworkScheduling.csproj --configuration Release
dotnet run --project .\startandgrowhyperscale\tests\CaldovaNetworkScheduling.Checks.csproj --configuration Release

For related script changes, run the corresponding mocked checks under startandgrowhyperscale\deploy\tests: part1-lifecycle.tests.ps1, pool-membership.tests.ps1, pool-deployment.tests.ps1, part1-pool.tests.ps1, or scheduling-network.tests.ps1. New pool deployment must pass explicit min/max limits; reuse mismatches stop instead of changing or recreating a pool.

The app checks with -- --live commit one synthetic Ridgeview booking. Require explicit target/identity approval; never classify that as read-only. 05-verify-sql.ps1 checks ARM, 03-verify.ps1 checks HTTP, and scheduling Verify uses the deployment identity. None substitutes for application-identity SQL proof.

Execute PowerShell operations synchronously, one script per call. Check exit code and completion. Do not use background deployment jobs or --no-wait. If execution continues after a tool timeout, read that same session rather than rerunning it. Never claim locally edited source has already been published.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.