Merge branch 'main' into main

Author: vbddr

.env.example

@@ -1,11 +1,11 @@
 # This file is a template for what your untracked .env file might look like for local development.
 # Please copy this to a new .env file and fill in the values as needed.
 
-# Requires a running local Elasticsearch service. Can be started via Docker, see https://github.com/github/docs-engineering/blob/main/docs/elasticsearch/elasticsearch-locally.md
+# Requires a running local Elasticsearch service. Can be started via Docker, see https://github.com/github/technical-content/blob/main/engineering/search/elasticsearch-locally.md
 # When this value is unset searches will be proxied to the production Elasticsearch endpoint
 ELASTICSEARCH_URL=http://localhost:9200
 
-# Set for sending events in local development. See https://github.com/github/docs-engineering/blob/main/docs/analytics/hydro-mock.md
+# Set for sending events in local development. See https://github.com/github/technical-content/blob/main/analytics/hydro-mock.md
 HYDRO_ENDPOINT=
 HYDRO_SECRET=
 

.github/CONTRIBUTING.md

@@ -82,7 +82,7 @@ For complete style guidance, see our [style guide](https://docs.github.com/en/co
 
 **Make changes locally:** 
 1. Fork the repository (see [official forking guide](https://docs.github.com/en/contributing))
-2. Install Node.js at the version specified in `.node-version` (see [development guide](../contributing/development.md))
+2. Install Node.js at the version specified in `package.json` (see [development guide](../contributing/development.md))
 3. Create a working branch and start with your changes
 
 ### Commit your update
@@ -100,7 +100,7 @@ Use our "[Self review checklist](https://docs.github.com/en/contributing/collabo
 - [Link PR to issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue) if applicable
 - Enable [maintainer edits](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/allowing-changes-to-a-pull-request-branch-created-from-a-fork)
 
-A Docs team member will review following our [standard review process](https://docs.github.com/en/contributing).
+A Technical Content team member will review following our [standard review process](https://docs.github.com/en/contributing).
 
 ### Your PR is merged!
 

.github/actions/create-workflow-failure-issue/action.yml

@@ -1,15 +1,20 @@
 name: Create workflow failure issue
-description: Create or update a GitHub issue in docs-engineering when a workflow fails, for automated diagnosis by an agentic workflow.
+description: Create or update a GitHub issue in technical-content when a workflow fails, for automated diagnosis by an agentic workflow.
 
 inputs:
   token:
     description: A token with issues write permission on the target repo
     required: true
   repo:
     description: The repository to create the issue in
-    default: github/docs-engineering
+    default: github/technical-content
     required: false
 
+outputs:
+  issue_url:
+    description: URL of the created or updated workflow-failure issue (empty if creation failed).
+    value: ${{ steps.create-new.outputs.issue_url || steps.comment-existing.outputs.issue_url }}
+
 runs:
   using: composite
   steps:
@@ -31,6 +36,7 @@ runs:
         echo "existing_issue=$existing" >> "$GITHUB_OUTPUT"
 
     - name: Comment on existing issue
+      id: comment-existing
       if: steps.check-existing.outputs.existing_issue != ''
       shell: bash
       env:
@@ -57,8 +63,10 @@ runs:
         gh issue comment "$ISSUE_NUMBER" \
           --repo "$ISSUE_REPO" \
           --body "$body"
+        echo "issue_url=$GITHUB_SERVER_URL/$ISSUE_REPO/issues/$ISSUE_NUMBER" >> "$GITHUB_OUTPUT"
 
     - name: Create workflow failure issue
+      id: create-new
       if: steps.check-existing.outputs.existing_issue == ''
       shell: bash
       env:
@@ -86,9 +94,10 @@ runs:
         This issue was automatically created by the create-workflow-failure-issue action to enable automated diagnosis.
         EOF
         )
-        gh issue create \
+        url=$(gh issue create \
           --repo "$ISSUE_REPO" \
           --label "workflow-failure" \
           --label "workflow-generated" \
           --title "[Workflow Failure] $WORKFLOW_NAME" \
-          --body "$body"
+          --body "$body")
+        echo "issue_url=$url" >> "$GITHUB_OUTPUT"

.github/actions/slack-alert/action.yml

@@ -10,13 +10,61 @@ inputs:
     default: CG5MJHMB2 # docs-alerts
     required: false
   message:
-    description: The message to send to Slack
-    default: The last '${{ github.workflow }}' run failed. See ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+    description: >-
+      Optional message override. When set, it is sent verbatim. When empty (the
+      default), a standard multi-line failure message is built from the run
+      context, plus a link to the failure issue if issue_url is provided.
+    default: ''
+    required: false
+  issue_url:
+    description: >-
+      Optional link to the tracking failure issue (e.g. the output of the
+      create-workflow-failure-issue action). Appended to the default message.
+      Ignored when a custom message is provided.
+    default: ''
     required: false
 
 runs:
   using: composite
   steps:
+    # Build the Slack text here so the default message can be multi-line (real
+    # newlines) and conditionally include the issue link. A caller-supplied
+    # message is passed through verbatim for backward compatibility.
+    - name: Build Slack message
+      id: build
+      shell: bash
+      env:
+        MESSAGE: ${{ inputs.message }}
+        ISSUE_URL: ${{ inputs.issue_url }}
+        SOURCE_REPO: ${{ github.repository }}
+        WORKFLOW_NAME: ${{ github.workflow }}
+        RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        EVENT_NAME: ${{ github.event_name }}
+        GIT_REF: ${{ github.ref }}
+        ACTOR: ${{ github.actor }}
+      run: |
+        # Escape Slack mrkdwn control chars in interpolated context fields so a
+        # crafted branch/ref (e.g. containing <!channel>) can't inject mentions.
+        esc() { printf '%s' "$1" | sed -e 's/&/\&amp;/g' -e 's/</\&lt;/g' -e 's/>/\&gt;/g'; }
+        # Unique heredoc delimiter so a custom message can't collide with it.
+        delim="SLACK_EOF_${RANDOM}${RANDOM}"
+        {
+          printf 'text<<%s\n' "$delim"
+          if [ -n "$MESSAGE" ]; then
+            printf '%s\n' "$MESSAGE"
+          else
+            printf ':actions: *Workflow failure* in %s: %s\n' "$(esc "$SOURCE_REPO")" "$(esc "$WORKFLOW_NAME")"
+            printf 'on %s · %s · by %s\n' "$(esc "$EVENT_NAME")" "$(esc "$GIT_REF")" "$(esc "$ACTOR")"
+            printf 'Run: %s\n' "$RUN_URL"
+            if [ -n "$ISSUE_URL" ]; then
+              printf 'Issue: %s\n' "$ISSUE_URL"
+            else
+              printf ':warning: No issue created\n'
+            fi
+          fi
+          printf '%s\n' "$delim"
+        } >> "$GITHUB_OUTPUT"
+
     - name: Send Slack notification if workflow fails
       uses: slackapi/slack-github-action@45a88b9581bfab2566dc881e2cd66d334e621e2c # v3.0.3
       with:
@@ -25,4 +73,4 @@ runs:
         errors: true
         payload: |
           channel: ${{ toJSON(inputs.slack_channel_id) }}
-          text: ${{ toJSON(inputs.message) }}
+          text: ${{ toJSON(steps.build.outputs.text) }}

.github/agents/builder-writer.md

@@ -0,0 +1,72 @@
+---
+
+name: "Builder-writer"
+description: "Use when writing, editing, or reviewing content for the Builder persona: developers building software, from junior to senior and solo to enterprise, who write, review, test, ship, and operate code."
+
+---
+
+# Builder-writer Agent
+
+You are a writing assistant for the GitHub Docs team. You help writers create, edit, and review documentation that serves the **Builder persona**.
+
+A Builder is the developer who turns an idea into working software. Their core job is to develop and maintain reliable software that meets the evolving needs of users and stakeholders. Builders write, review, test, ship, and operate code, and they work in many contexts: proprietary software at companies and startups, open source, security, developer advocacy, and AI innovation.
+
+When making content decisions, you can write for a Builder who is a somewhat experienced developer: you do not need to teach them coding basics, but you should comment code examples, explain the reasoning behind decisions, and be explicit about prerequisites such as installing libraries or configuring tools.
+
+Builders are a **diverse group**, and content should account for the range:
+
+* **Expertise** varies from junior to senior. A developer in their first job and one with a decade of experience are both Builders with different needs.
+* **Team size** varies from solo hobbyists, to a startup team, to hundreds of developers across teams at a large enterprise.
+* **Roles** vary, and include software engineers, DevOps engineers, security engineers, and open source maintainers and contributors.
+
+## What makes Builder content different
+
+Builder content is distinct from content for the Driver persona (people who enable developers at scale, such as enterprise administrators). Apply these when writing or editing.
+
+### Lead with well-crafted examples
+
+Examples are one of the most valuable resources for developers and one of the most under-served, so this is a way for GitHub Docs to stand out. Builders want to see how something works in a relevant scenario and adapt it to their needs, not just read about it. When writing examples:
+
+* Follow best practices, so readers can copy the pattern with confidence.
+* Explain what each part does and why.
+* Choose scenarios that are easy to copy, with clear explanations about things Builders may need to adapt to their needs.
+
+When you show a command or an example prompt a reader can run against their own project, make it easy to try directly: a copyable command, or a prompt they can paste straight into the tool. Builders copy and adapt what they see, so be explicit when an example is just one illustrative approach rather than the required or only way to do something.
+
+### Write for someone who works in code
+
+Builders are configuring their environment, writing functions, debugging builds, and wiring up tests. They want concrete implementation detail: how to integrate a library, what a configuration file should contain, how settings affect a build. Explain the decisions behind a recommended approach so a reader can adapt it to their own codebase, rather than only listing steps to click through.
+
+### Cover the command line and API, not just the UI
+
+Builders frequently work outside the web UI, and non-UI flows are critical for this persona. When a task is tedious, repetitive, or not realistic to accomplish in the UI, show how to do it with the Copilot CLI, GitHub CLI, or the API. For workflows that can be scripted or automated, treat the programmatic path as a first-class option rather than an afterthought.
+
+### Frame value around the developer's own work
+
+Builders care about their craft: shipping working software, writing clean and secure code, and collaborating effectively. Connect features to that work, the way a developer experiences it day to day, rather than to enterprise-level outcomes like compliance posture or cost management.
+
+* Instead of: "Code scanning helps your organization meet its security requirements."
+* Write: "Code scanning flags vulnerabilities in your pull request before they reach the main branch, so you can fix them while the change is fresh."
+
+### Help Builders do the work around the code well
+
+Much of a Builder's day is the practice surrounding the code: scoping an issue, opening a reviewable pull request, giving and responding to review feedback, and setting up CI to catch problems early. This is fertile ground for opinionated, practical guidance (for example, how to write a well-defined issue, or how to keep a pull request scoped and easy to review). Help Builders discover and adopt these practices, and connect the relevant features so they see how planning, coding, reviewing, testing, and shipping fit together.
+
+### Keep the focus on the developer's hands-on work
+
+Builder content sits at the altitude of a developer doing the work themselves. When a draft drifts into rolling out, governing, or administering a tool across an organization, that is Driver territory. Split that content into a separate article or hand it off rather than mixing a developer audience and an admin audience in one piece. For example, a best-practices guide for using a tool should stay focused on the individual developer's workflow, not how to deploy the tool at scale across a company.
+
+### Present GitHub's tools as one connected ecosystem
+
+Builders move fluidly between surfaces (the CLI, the IDE, the web, and integrations), often within a single subscription, and switch based on what they are working on. Frame each tool's value on its own merits and show how the surfaces work together. Do not promote one surface by contrasting it negatively against another GitHub option, since the goal is for Builders to use the right tool for each task, not to pick one over another.
+
+## Builder user journey
+
+Builders move through the software development lifecycle. Content should meet them where they are in this flow:
+
+* **Plan**: Exploring opportunities, picking up and understanding work, and designing an approach against requirements.
+* **Create**: Setting up an environment, authoring and optimizing code, and finding and fixing security issues.
+* **Review**: Reviewing others' code for quality and security, and responding to feedback on their own.
+* **Test**: Writing and running tests, interpreting results, and debugging failures.
+* **Deploy**: Initiating and overseeing a release, then validating a successful deployment.
+* **Operate**: Monitoring system health and performance, and maintaining and improving reliability.

.github/instructions/code.instructions.md

@@ -50,7 +50,6 @@ Some test suites depend on fixture content or external services. These suites ha
 
 ```shell
 npm run test:article-api
-npm run test:changelogs
 npm run test:fixtures
 npm run test:landings
 npm run test:languages    # requires Elasticsearch running

.github/instructions/content-guidelines.instructions.md

@@ -19,6 +19,20 @@ The strategic priority is simplification: create less content and remove content
 * Would a typical internet user figure this out on their own by exploring the UI?
 * Is the information presented at the moment the reader actually needs it?
 
+## Give opinionated, actionable guidance
+
+This applies whenever you give the reader advice or present ways to accomplish a task.
+
+* Be opinionated when there is a better way: when several approaches exist, recommend the best one and explain why, rather than presenting all options as equally valid. When they are genuinely equivalent, stay neutral.
+* Tell users the best practice AND how to follow it: whenever you state a best practice, pair it with concrete steps or an example so the reader can act on it, never the advice alone.
+
+## Focus on the reader's purpose, not the product
+
+Frame an article around what the reader is trying to accomplish, not the product or feature they use to do it. This applies when naming an article or deciding what a new or substantially reworked article should cover; do not use it to justify restructuring an article during a small edit.
+
+* Title articles by the reader's goal, not the product or feature. For example, "Secure your enterprise", not "Use GitHub Advanced Security".
+* Scope articles around a task, not a product. When a task naturally spans multiple features or products, look for the opportunity to cover them together in one task-focused article or tutorial rather than splitting into per-product articles. Keep each article to a single purpose (the task): combine features only when they serve that same task, not to bundle unrelated capabilities.
+
 ## Intros: pull people in
 
 This section applies mainly to the `intro` frontmatter field and, for conceptual articles, section openings.
@@ -40,6 +54,7 @@ Examples of strong intros by content type:
 * Only include a CTA link when it genuinely makes the reader's task easier, for example by saving them the time of navigating to a settings page themselves. Do not force a CTA; if none would genuinely help the reader, do not add one. Avoid turning articles into clickbait.
 * A CTA can take several forms, for example a direct link to the relevant product or feature, a Copilot prompt the reader can run, or a link to start a free trial.
 * Only link to a URL that is the same for everyone on that version. Do not add a CTA when the in-product URL must include an enterprise, organization, or repository name (for example, `https://github.com/ORG/REPO/settings/copilot/code_review`), because the link cannot be made to work for all readers.
+* Place a CTA as close as possible to the step where the reader completes the task it supports. A CTA near the final step measurably reduces time-to-task, while a CTA at an early step (for example, at the start of a multi-step setup) does not change whether or how quickly readers finish.
 * Procedural articles: include a CTA wherever one genuinely helps, as directly as possible.
 * Conceptual articles: point the reader to exactly one clear next step, usually a link to the related procedure (for example, an "About pull requests" article points to "Creating a pull request"). Place it where the reader is ready to act, typically at the end of the article.
 

.github/instructions/instruction-architecture.instructions.md

@@ -0,0 +1,13 @@
+---
+applyTo: ".github/instructions/**,.github/agents/**"
+---
+
+# Editing Copilot content instruction and agent files
+
+This applies when you add, edit, or remove a Copilot instruction or shared agent file that guides how **content** (articles, data files) is written. It does **not** apply to code instructions or agents owned by the engineering team (for example `code.instructions.md`).
+
+When it applies, you **must** first read the instruction-architecture doc in full and follow it:
+
+https://github.com/github/technical-content/blob/main/contributing-to-docs/docs-work/copilot-instruction-architecture.md
+
+Read the current version every time (from a local `github/technical-content` checkout if you have one, otherwise fetch the URL); do not rely on your memory of it, because it changes. If you cannot access it, say so and stop rather than guessing.

.github/instructions/style-guide-summary.instructions.md

@@ -50,6 +50,14 @@ For Liquid variable usage, reusables, linking conventions, bullet-list markers,
 * Keep alerts concise (a couple of sentences max).
 * Use Markdown syntax: `> [!NOTE]`, `> [!TIP]`, `> [!WARNING]`, `> [!CAUTION]`, `> [!IMPORTANT]`.
 
+Call reusable content inside alert environments, rather than placing alert environments inside reusable Markdown files. For example:
+
+```
+> [!CAUTION]
+> {% data reusables.foo.bar %}
+> Here is some additional optional text.
+```
+
 ## Links
 
 * Introduce links with "For more information, see" or "See" when context is clear.
@@ -59,7 +67,7 @@ For Liquid variable usage, reusables, linking conventions, bullet-list markers,
 
 ## Lists
 
-* Capitalize the first letter of each list item.
+* Capitalize the first letter of each list item, including the first letter after the colon in a term definition list (for example, `* **Filesystem**: Grant read-only access...`).
 * Use periods only if the item is a complete sentence.
 * Introduce lists with a descriptive sentence, not vague phrases like "the following" in isolation.