Official agent skill

Wellknown Analyzer

by microsoft in microsoft/terraform-provider-fabric

Analyze dependencies and determine what infrastructure must be added to tools/scripts/Set-WellKnown.ps1 and internal/testhelp/wellknown.go so that acceptance tests for a new resource have all…

OfficialMPL-2.0Auto-check passedTesting & QA

Install Wellknown Analyzer

skills CLI
$ npx skills add microsoft/terraform-provider-fabric --skill wellknown-analyzer -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install microsoft/terraform-provider-fabric wellknown-analyzer --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/microsoft/terraform-provider-fabric.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.github/skills/wellknown-analyzer .claude/skills/wellknown-analyzer && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
wellknown-analyzer
GitHub stars
128
Token cost
~3.2k tokens
SKILL.md length
960 words
Files
1
Skills in repo
5
Repo updated
First seen
Licence
MPL-2.0

At a glance

Analyze dependencies and determine what infrastructure must be added to tools/scripts/Set-WellKnown.ps1 and internal/testhelp/wellknown.go so that acceptance tests for a new resource have all…

  • Works in 5 steps: Analyze the New Resource's Dependencies → Check Current Well-Known Script → Determine the Creation Strategy → …
  • : analyzing well-known test fixture requirements for new resources
  • SKILL.md covers Background, Step 1 — Analyze the New…, Step 2 — Check Current… and Step 3 — Determine the…, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Wellknown Analyzer is an agent skill from microsoft/terraform-provider-fabric, published by the product's own GitHub organization. Analyze dependencies and determine what infrastructure must be added to tools/scripts/Set-WellKnown.ps1 and internal/testhelp/wellknown.go so that acceptance tests for a new resource have all required pre-requisite resources available. USE FOR: analyzing well-known test fixture requirements for new resources, determining creation strategies, and generating code snippets for Set-WellKnown.ps1 and wellknown.go additions.

Its SKILL.md is about 3.2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Testing & QA, covering End-to-end testing and Test data and fixtures. It works with Microsoft Azure and Terraform. The repository describes itself as: Terraform Provider for Microsoft Fabric. The licence is MPL-2.0.

When your agent uses it

  • : analyzing well-known test fixture requirements for new resources
  • Determining creation strategies
  • Generating code snippets for Set-WellKnown.ps1 and wellknown.go additions

Example prompts

  • “/wellknown-analyzer”

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Analyze the New Resource's Dependencies
  2. Check Current Well-Known Script
  3. Determine the Creation Strategy
  4. Check for Ordering Requirements
  5. Produce the Recommendation

What it can do on your machine

Read from SKILL.md and the folder at commit 86c83be. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are powershell and go).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Wellknown Analyzer loads about 3.2k tokens when it runs. Until then it costs about 110 tokens; SKILL.md has 960 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~110
When it runs · the whole SKILL.md, loaded when a task matches
~3.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from microsoft/terraform-provider-fabric at commit 86c83be, republished under its MPL-2.0 licence (© microsoft). 960 words, ~3,236 tokens.

Download SKILL.mdSave it as .claude/skills/wellknown-analyzer/SKILL.md (or your agent's skills folder).
name
wellknown-analyzer
description
Analyze dependencies and determine what infrastructure must be added to tools/scripts/Set-WellKnown.ps1 and internal/testhelp/wellknown.go so that acceptance tests for a new resource have all required pre-requisite resources available. USE FOR: analyzing well-known test fixture requirements for new resources, determining creation strategies, and generating code snippets for Set-WellKnown.ps1 and wellknown.go additions.

Skill: Well-Known Analyzer

Determine what infrastructure must be added to tools/scripts/Set-WellKnown.ps1 so that acceptance tests for a new resource have all required pre-requisite resources available.

Background

Acceptance tests run against real Fabric APIs and need pre-existing infrastructure. The PowerShell script tools/scripts/Set-WellKnown.ps1 creates all required resources and writes their IDs/metadata to a .wellknown.json fixture that tests consume at runtime.

When adding a new resource, you must determine:

  1. Can the new resource be created simply (no payload, no definition)?
  2. Does it need a CreationPayload or Definition?
  3. Does it depend on other Fabric Items that must exist first?
  4. Does it require Azure infrastructure (Resource Groups, VNets, Storage Accounts, etc.)?
  5. Does it need Entra ID objects (service principals, groups)?
  6. Does it need external service connections (AzDO, GitHub)?

Step 1 — Analyze the New Resource's Dependencies

Read the SDK analysis (from #skill:sdk-contract-navigator) and Fabric API documentation to answer:

Fabric Resource Dependencies
QuestionHow to CheckExample
Does Create require a workspace_id?Almost always yesAll workspace-scoped items
Does Create require another resource's ID?Check CreationPayload for reference fieldsKQL Database needs parentEventhouseItemId
Does Create require a Definition?Check if API requires definition on createReport needs definition.pbir, Semantic Model needs definition.pbism
Does it have a parent resource relationship?Check if resource is scoped under anotherDigitalTwinBuilderFlow requires a DigitalTwinBuilder
Does it need data populated after creation?Check if tests rely on resource contentLakehouse needs sample data loaded for shortcut tests
Azure Infrastructure Dependencies
QuestionHow to CheckExample
Does it need an Azure Resource Group?Check if the resource references Azure resourcesMounted Data Factory, VNet Gateway
Does it need a Storage Account?Check for blob/storage referencesManaged Private Endpoints
Does it need a Virtual Network?Check for VNet/subnet referencesVirtual Network Gateway
Does it need an Azure Data Factory?Check for ADF referencesMounted Data Factory
Does it need Azure RBAC assignments?Check if Azure roles must be pre-assignedNetwork Contributor on VNet
Entra ID Dependencies
QuestionHow to CheckExample
Does it need a Service Principal?Check for role assignment testsRole assignment resources
Does it need an Entra Group?Check for group-based assignmentsWorkspace role assignments
Does it need specific app registrations?Check for OAuth/auth requirementsConnection resources
External Service Dependencies
QuestionHow to CheckExample
Does it need an AzDO project/repo?Check for Git integrationWorkspace Git
Does it need a GitHub connection?Check for GitHub referencesWorkspace Git
Does it need a Fabric Connection?Check for connection referencesConnection role assignments
Does it need a Gateway?Check for gateway-scoped operationsGateway role assignments, VNet connections

Step 2 — Check Current Well-Known Script

Read tools/scripts/Set-WellKnown.ps1 to determine what already exists and what's missing.

Check the Set-FabricItem switch block

Look at the switch ($Type) block in the Set-FabricItem function. If the new item type is missing, it needs an entry mapping to its REST API endpoint:

powershell
'<NewItemType>' {
    $itemEndpoint = '<camelCasePluralEndpoint>'
}

The endpoint is the camelCase plural of the item type (e.g. lakehouses, eventhouses, sqlDatabases, dataPipelines).

Check the $itemNaming hashtable

Every item that gets created needs a short naming abbreviation in $itemNaming:

powershell
'<NewItemType>' = '<2-5 char abbreviation>'
Check existing creation patterns

Determine which creation pattern applies.

Step 3 — Determine the Creation Strategy

Strategy A: Simple Item (no payload, no definition)

If the Fabric API can create the item with just displayName and description, add it to the $itemTypes array:

powershell
$itemTypes = @('ApacheAirflowJob', ..., '<NewItemType>', ..., 'Warehouse')

The loop handles creation automatically:

powershell
foreach ($itemType in $itemTypes) {
    $displayNameTemp = "${displayName}_$($itemNaming[$itemType])"
    $item = Set-FabricItem -DisplayName $displayNameTemp -WorkspaceId $wellKnown['WorkspaceDS'].id -Type $itemType
    $wellKnown[$itemType] = @{
        id          = $item.id
        displayName = $item.displayName
        description = $item.description
    }
}

Fabric Items currently using this pattern: ApacheAirflowJob, CopyJob, Dataflow, DataPipeline, DigitalTwinBuilder, Environment, Eventhouse, GraphQLApi, KQLDashboard, KQLQueryset, Lakehouse, Map, MLExperiment, MLModel, Notebook, Reflex, SparkJobDefinition, SQLDatabase, VariableLibrary, Warehouse

Show full SKILL.md (377 more words)Show less
Strategy B: Item with CreationPayload

If the API requires a creationPayload on create, add a dedicated block after any dependencies have been created:

powershell
# Create <NewItemType> if not exists
$displayNameTemp = "${displayName}_$($itemNaming['<NewItemType>'])"
$creationPayload = @{
    <requiredField> = <value>
}
$item = Set-FabricItem -DisplayName $displayNameTemp -WorkspaceId $wellKnown['WorkspaceDS'].id -Type '<NewItemType>' -CreationPayload $creationPayload
$wellKnown['<NewItemType>'] = @{
    id          = $item.id
    displayName = $item.displayName
    description = $item.description
}

Current examples:

  • KQLDatabase — needs databaseType and parentEventhouseItemId (depends on Eventhouse)
  • DigitalTwinBuilderFlow — needs digitalTwinBuilderItemReference (depends on DigitalTwinBuilder)
  • WarehouseSnapshot — needs parentWarehouseId (depends on Warehouse)
Strategy C: Item with Definition

If the API requires a definition on create (items that are definition-required):

powershell
$displayNameTemp = "${displayName}_$($itemNaming['<NewItemType>'])"
$definition = @{
    parts = @(
        @{
            path        = '<definition-path>'
            payload     = Get-DefinitionPartBase64 -Path 'internal/testhelp/fixtures/<item_type>/<file>.tmpl' -Values @(
                @{ key = '{{ .PlaceholderVar }}'; value = $actualValue }
            )
            payloadType = 'InlineBase64'
        }
    )
}
$item = Set-FabricItem -DisplayName $displayNameTemp -WorkspaceId $wellKnown['WorkspaceDS'].id -Type '<NewItemType>' -Definition $definition
$wellKnown['<NewItemType>'] = @{
    id          = $item.id
    displayName = $item.displayName
    description = $item.description
}

Current examples:

  • MirroredDatabase — needs mirroring.json definition
  • SemanticModel — needs definition.pbism + model.bim
  • Report — needs definition.pbir + report.json + static resources (depends on SemanticModel)
  • Eventstream — needs eventstream.json definition (depends on Lakehouse)
  • MountedDataFactory — needs mountedDataFactory-content.json (depends on Azure Data Factory)

This strategy also requires:

  1. Create template fixture files in internal/testhelp/fixtures/<item_type>/
  2. Use Get-DefinitionPartBase64 to Base64-encode the definition content
Strategy D: Non-Fabric-Item Infrastructure

For non-Fabric-Item resources that need dedicated setup:

Azure resources:

powershell
# Create Azure resource
$resource = Set-Azure<Resource> -ResourceGroupName $wellKnown['ResourceGroup'].name -Name $displayNameTemp ...
$wellKnown['<ResourceKey>'] = @{
    id   = $resource.Id
    name = $resource.Name
}

Fabric connections:

powershell
$connection = Set-FabricConnection -DisplayName $displayNameTemp -ConnectivityType "<type>"
$wellKnown['<ConnectionKey>'] = @{
    id          = $connection.id
    displayName = $connection.displayName
}

Role assignments:

powershell
Set-FabricGatewayRoleAssignment -GatewayId $gatewayId -PrincipalId $principalId -PrincipalType 'ServicePrincipal' -Role 'Admin'

Domains:

powershell
$domain = Set-FabricDomain -DisplayName $displayNameTemp
$wellKnown['<DomainKey>'] = @{ id = $domain.id; displayName = $domain.displayName }

Step 4 — Check for Ordering Requirements

Well-known resources are created sequentially. Ensure dependencies are created before dependents:

  1. Azure infrastructure first — Resource Groups, VNets, Storage Accounts, Data Factories
  2. Workspaces second — WorkspaceMPE, WorkspaceOAP, WorkspaceRS, WorkspaceDS
  3. Simple Fabric Items third — items in the $itemTypes array
  4. Dependent Fabric Items fourth — items that reference other items (KQLDatabase→Eventhouse, DigitalTwinBuilderFlow→DigitalTwinBuilder)
  5. Fabric Items with definitions fifth — items requiring definition fixtures
  6. Non-item resources sixth — Connections, Gateways, Domains, etc.
  7. Sub-resources last — Role assignments, shortcuts, folders, schedulers

If the new resource depends on something not yet created, note it as a prerequisite.

Step 5 — Produce the Recommendation

Output a structured recommendation:

Summary
Resource: fabric_<name>
Category: Fabric Item / non-item
Creation Strategy: A (simple) / B (payload) / C (definition) / D (non-item infra)
Dependencies Found

List all identified dependencies:

✅ Already exists: <dependency>
❌ Missing: <dependency> — needs to be added
Required Changes to Set-WellKnown.ps1
  1. Switch block — Add/confirm entry
  2. $itemNaming — Add abbreviation
  3. Creation logic — Add to array or add dedicated block
  4. $wellKnown output — Ensure entry is written
  5. Fixture files — List any template files needed in internal/testhelp/fixtures/
  6. Azure infra — List any Azure resources needed
  7. Ordering — Where in the script the new code should be placed
Code Snippets

Provide ready-to-paste PowerShell code for each required change.

Go Access Pattern (wellknown.go)

Well-known data is loaded from internal/testhelp/fixtures/.wellknown.json (or the FABRIC_TESTACC_WELLKNOWN env var) and accessed in tests via:

go
entity := testhelp.WellKnown()["Lakehouse"].(map[string]any)
entityID := entity["id"].(string)
Key Workspaces
KeyPurpose
WorkspaceRSResource tests (create/update/delete)
WorkspaceDSData source tests (read-only)
WorkspaceMPEManaged private endpoint tests
WorkspaceOAPOutbound access policy tests

Reference

  • Well-known setup script: tools/scripts/Set-WellKnown.ps1
  • Well-known Go accessor: internal/testhelp/wellknown.go
  • Test fixture directory: internal/testhelp/fixtures/
  • Well-known JSON output: internal/testhelp/fixtures/.wellknown.json

© microsoft, MPL-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .github/skills/wellknown-analyzer of microsoft/terraform-provider-fabric.

Open the folder on GitHubat commit 86c83be

Compare with similar skills

Wellknown Analyzer next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Wellknown Analyzer compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Wellknown Analyzer this skillmicrosoft/terraform-provider-fabric128—~3.2kAutomated safety check: PassMPL-2.0
Avm Tf TestingAzure/terraform-azurerm-avm-ptn-alz135—~1.8kAutomated safety check: PassMIT
Java SDK E2E Test with Replay Snapshotgithub/copilot-sdk11k—~1.8kAutomated safety check: PassMIT
source-mssql E2E Test Harnessairbytehq/airbyte22k—~4.4kAutomated safety check: PassCustom licence
Airbyte source-mysql E2E Testsairbytehq/airbyte22k—~2.6kAutomated safety check: PassCustom licence
Airbyte Postgres Source E2E Testsairbytehq/airbyte22k—~2.5kAutomated safety check: PassCustom licence

Similar skills

  • Avm Tf Testing

    Azure/terraform-azurerm-avm-ptn-alz

    Official

    A skill your agent uses for AVM Terraform validation, provider-mocked unit tests, real-Azure integration tests, E2E example tests, PowerShell hooks, OIDC, policy checks, and Avm.Authoring CI behavior.

    135 GitHub stars~1.8k tokensUpdated yesterday
    Testing & QAAuto-check passed
  • Official

    Creates a Java SDK end-to-end test for the Copilot SDK that runs against a recorded YAML snapshot through a replay proxy, so CI needs no real authentication.

    11k GitHub stars~1.8k tokensUpdated today
    Testing & QAAuto-check passed
  • Official

    Stands up a throwaway local SQL Server 2022 backend, applies SQL fixtures and runs Airbyte spec, check, discover and read against source-mssql images.

    22k GitHub stars~4.4k tokensUpdated today
    Testing & QAAuto-check passed
  • Official

    Stands up a throwaway local MySQL 8.0 backend, applies SQL fixtures and sweeps the Airbyte spec, check, discover and read commands against a source-mysql image.

    22k GitHub stars~2.6k tokensUpdated today
    Testing & QAAuto-check passed
  • Official

    Starts a local PostgreSQL 16 container, loads SQL fixtures and runs the Airbyte spec, check, discover and read commands against a chosen source-postgres image.

    22k GitHub stars~2.5k tokensUpdated today
    Testing & QAAuto-check passed
  • Run E2E Test

    kubernetes-sigs/cloud-provider-azure

    Official

    Parse a Go e2e test from tests/e2e/, translate each step to kubectl and az CLI commands, and interactively replay the test against a live cluster.

    294 GitHub stars~3.8k tokensUpdated today
    Testing & QAAuto-check passed

More from microsoft/terraform-provider-fabric

  • Itemgen Command Builder

    microsoft/terraform-provider-fabric

    Official

    Given SDK analysis results, automatically determine the correct itemgen archetype and build the full go run tools/itemgen/main.go command.

    128 GitHub stars~1.5k tokensUpdated yesterday
    Auto-check passed
  • Schema Model Generator

    microsoft/terraform-provider-fabric

    Official

    Given a Go SDK contract (DTOs), generate the corresponding Terraform schema attributes and model structs with high fidelity.

    128 GitHub stars~2.5k tokensUpdated yesterday
    Auto-check passed
  • SDK Contract Navigator

    microsoft/terraform-provider-fabric

    Official

    Navigate the fabric-sdk-go SDK source to find the correct client factory, DTOs, item type constants, and pager methods for a given Fabric Item or non-item resource.

    128 GitHub stars~3k tokensUpdated yesterday
    Auto-check passed
  • Resource Designer

    microsoft/terraform-provider-fabric

    Official

    Research SDK contracts, design Terraform schema approach, and compose a GitHub issue for a new resource, data source, ephemeral resource, or enhancement to an existing resource.

    128 GitHub stars~6k tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Wellknown Analyzer

What does Wellknown Analyzer do?

Analyze dependencies and determine what infrastructure must be added to tools/scripts/Set-WellKnown.ps1 and internal/testhelp/wellknown.go so that acceptance tests for a new resource have all…. Wellknown Analyzer is an agent skill from microsoft/terraform-provider-fabric, published by the product's own GitHub organization.go so that acceptance tests for a new resource have all required pre-requisite resources available.

When should I use Wellknown Analyzer?

Wellknown Analyzer fits situations like: : analyzing well-known test fixture requirements for new resources; determining creation strategies; generating code snippets for Set-WellKnown.ps1 and wellknown.go additions.

How do I install Wellknown Analyzer in Claude Code?

Run `npx skills add microsoft/terraform-provider-fabric --skill wellknown-analyzer -a claude-code`. Or copy the skill folder (.github/skills/wellknown-analyzer in microsoft/terraform-provider-fabric) into .claude/skills/wellknown-analyzer in your project. Claude Code loads it when a task matches its description.

How do I install Wellknown Analyzer in Codex?

Run `npx skills add microsoft/terraform-provider-fabric --skill wellknown-analyzer -a codex`. Or copy the skill folder (.github/skills/wellknown-analyzer in microsoft/terraform-provider-fabric) into .agents/skills/wellknown-analyzer in your project. Codex loads it when a task matches its description.

Can I use Wellknown Analyzer in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add microsoft/terraform-provider-fabric --skill wellknown-analyzer -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/wellknown-analyzer, .gemini/skills/wellknown-analyzer, .github/skills/wellknown-analyzer and .opencode/skills/wellknown-analyzer in your project.

What does Wellknown Analyzer need to run?

SKILL.md names no scripts, command-line tools or credentials: Wellknown Analyzer is instructions for the agent only.

Does Wellknown Analyzer access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Wellknown Analyzer safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Wellknown Analyzer use?

Wellknown Analyzer is published under the MPL-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Wellknown Analyzer use?

About 3.2k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Wellknown Analyzer?

Skills that share tags, products or a category with Wellknown Analyzer: Avm Tf Testing (Azure/terraform-azurerm-avm-ptn-alz, 135 stars), Java SDK E2E Test with Replay Snapshot (github/copilot-sdk, 11k stars), source-mssql E2E Test Harness (airbytehq/airbyte, 22k stars) and Airbyte source-mysql E2E Tests (airbytehq/airbyte, 22k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Wellknown Analyzer?

microsoft (a GitHub organization, an official publisher) maintains it in microsoft/terraform-provider-fabric, which has 128 GitHub stars. The repository holds 5 skills in this directory. The repository was last updated on October 6, 2026.

Source: microsoft/terraform-provider-fabric on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.