Build a Human-Gated Linear Workflow

Turn Linear issues into draft GitHub pull requests with human review.

Introduction

30 Second Summary

A fast change can still be the wrong change. Someone needs to check what changed before it reaches everyone else.

In this project, you will build a controlled workflow that turns a rough Linear request into a reviewed GitHub pull request. Linear Agent performs the implementation before GitHub Actions checks the proposal under your manual merge gate.

What You'll Build

You can demo a vague Linear issue becoming a scoped task before a draft GitHub pull request stops at your review gate.

By the end of this project, you'll have:

A connected ticket-to-PR path that lets you delegate one Linear issue and receive a linked draft GitHub pull request for review.
A reusable Agent-ready ticket skill that turns vague requests into scope, non-goals, acceptance criteria, and validation expectations.
A human-controlled release gate where you inspect GitHub Actions checks before performing the merge yourself.
Secret Mission: Reuse the saved skill on a second vague issue without starting another paid coding session.

Are there any prerequisites?

You need a Linear workspace plus an existing GitHub repository that already runs GitHub Actions. You may also need a Linear owner or administrator to approve repository access.

Before We Start

A human-gated workflow starts with an existing GitHub repository that already uses GitHub Actions. This checkpoint locks in that target plus your reason for keeping the final merge decision human-controlled.

Connect Linear to GitHub Safely

Your target repository already has GitHub Actions guarding changes. Linear still has no permission to reach it through GitHub.

Linear Coding Sessions needs explicit repository access before Linear Agent can return a reviewable pull request.

AI credits make the implementation run available. Workflow rules preserve the human merge boundary.

In this step, get ready to:

Limit Linear's repository access to your selected repository.
Enable funded Coding Sessions with status safeguards.
Create a constrained coding environment that stops at a draft pull request.

Connect the repository and your identity

The GitHub integration forms the permission bridge between your issue tracker and repository. A narrow installation keeps the trial contained to the repository you already selected.

In Linear, select Settings.
Select Features.
Select Integrations.
Select GitHub.

Keep repository access narrow

Repository access is sensitive, so this is a good point to slow down. The installation should cover only the target repository for this project.

Continue with a Linear owner or admin who has the required GitHub organization permissions.
Ask the appropriate Linear or GitHub administrator to complete the installation if your account lacks permission.

Select Enable.
Choose the GitHub organization that contains the target repository.
Select only the target repository.
Grant repository code access during installation.
Complete the GitHub installation flow.

You should see the target repository included in the installed integration scope. No other repository needs access for this trial.

Return to Settings in Linear.
Select Connected accounts.
Connect your personal GitHub account.
Complete the GitHub authorization prompt.

You should see your personal GitHub account listed in Linear. That identity now attributes synchronized GitHub activity to you.

Repository or account missing?

Ask your Linear owner or admin to confirm that the target repository was included in the GitHub installation.
Ask the administrator to confirm that repository code access was granted.
Reconnect your personal GitHub account if your identity does not appear under Connected accounts.

Still stuck? Help me troubleshoot my Linear GitHub integration and connected account.

Enable Coding Sessions and status safeguards

Coding Sessions need an available AI-credit balance before implementation can begin. Status automation then keeps the Linear issue aligned with the pull request lifecycle.

Check the cost before continuing

This is the only point in the step that can add prepaid spend. A promotional balance avoids a top-up.

Coding Sessions consume model tokens at provider-published rates. Sandbox runtime costs $0.25 per 20-minute block.

Failed runs can still consume credits for the resources used. Partial runs can consume credits too.

Return to Linear Settings from earlier.
Select Workspace.
Select Billing.
Select AI Usage and credits.
Check whether the workspace has a promotional balance.
Add the minimum $10 USD top-up only if no promotional balance is available.

You should now see an available AI-credit balance. The coding session has a funding source without changing your human-only merge rule.

Return to Features in Linear Settings.
Select AI & agents.
Select Linear Agent.
Select Coding sessions.
Set Coding Sessions to Enabled.

You should see Coding Sessions enabled for the workspace. Members with connected GitHub accounts can now start sessions from implementation-ready issues.

Pull request automation turns repository events into visible issue progress. The started status shows that work is underway. The completed status remains tied to the human-approved merge.

In Linear Settings, select Team.
Select Workflows & automations.
Select Pull request and commit automations.
Map opened pull requests to the team's started status.
Map draft pull requests to the team's started status.
Map merged pull requests to the team's completed status.

You should see opened and draft pull request events mapped to the started status. You should also see the merged event mapped to the completed status.

Billing or Coding Sessions controls missing?

Ask a Linear owner or admin to complete workspace billing controls that your role cannot change.
Ask a Linear owner or admin to enable Coding Sessions if the setting is unavailable.
Confirm that the GitHub integration installation finished before configuring pull request automation.

Need help checking the workspace controls? Help me identify which Linear administrator action is still missing.

Create a constrained coding environment

A repository-specific environment tells the agent where it can work. Custom guidance defines the boundaries that keep this first run low risk.

Return to Workspace settings in Linear.
Select AI & Agents.
Select Coding sessions.
Select Environments.

You should see that the target repository is absent from active environments. This confirms that you are creating its first environment for this project.

Create an environment for the target repository.

You should see the environment configuration screen. This is where you attach the repository and define the session boundaries.

Attach the target repository to the environment.
Keep model selection on Auto unless your workspace has an established standard.

You should see the target repository selected. The model field should show Auto unless your workspace standard specifies another selection.

In the Custom guidance field, enter Change only files required by the acceptance criteria. Do not change source code, dependencies, or GitHub Actions workflow files during this trial. Run existing applicable checks and report what ran. Create a draft pull request. Stop for human review and never merge.
Save the environment.

You should see one active environment attached to the target repository. Its guidance allows a bounded change while keeping the merge decision with you.

Before you verify the setup, how many active environments do you expect to contain the target repository?

Return to Environments from earlier.
Confirm that the target repository appears in one active environment.
Open the active environment.
Confirm that the model selection shows Auto unless a workspace standard applies.
Confirm that Custom guidance contains the five trial boundaries you entered.
Return to Linear Settings.
Select Connected accounts.
Confirm that your personal GitHub account appears.

You should see the target repository in exactly one active environment. You should also see your personal GitHub account connected in Linear.

Environment or connected account missing?

Check whether the target repository is attached to another active environment.
Ask a Linear owner or admin to confirm that Coding Sessions remain enabled.
Reconnect your personal GitHub account if it no longer appears under Connected accounts.

Still unable to verify the setup? Help me troubleshoot my Linear coding environment and GitHub connection.

Your repository now has a funded and constrained path from Linear to a draft pull request. Next, you'll test what happens when the ticket asks for investigation without authorizing a concrete implementation.

Observe a Scoping-Only Ticket

The target repository now has a constrained path through Linear. Its coding environment limits agent work to the trial boundaries.

GitHub Actions supplies automated evidence. Your human merge gate still controls shipping.

A request to investigate sounds useful without authorizing a concrete implementation. In this step, you will give Linear Agent that ambiguous request. You will inspect what the wording actually authorizes.

In this step, get ready to:

Create an intentionally vague issue about contributor onboarding.
Delegate the issue while retaining human ownership.
Diagnose why the response stops at scoping.

Create an intentionally weak ticket

An investigation request names a topic. It leaves the implementation deliverable undefined.

Press C in Linear to open the issue creation modal.
Enter Improve contributor onboarding as the issue title.
Enter Investigate how we could make contributor onboarding clearer. as the issue description.
Leave your name selected as the issue's human assignee.
Submit the issue using the creation control at the bottom of the modal.

You should see the open issue with the title and description you entered. Good work. You now have a realistic vague request to test without risking repository changes.

Delegate the issue

Agent delegation lets Linear Agent work on an issue while a human assignee stays responsible. Your name remains on the ticket throughout this test.

Open the assignment menu on the issue.
Select Linear Agent as the delegated agent.
Confirm that your name remains the human assignee.

That ownership split is now in place. Linear Agent can respond while you remain accountable for the issue.

Inspect the scoping response

The issue activity reveals how Linear Agent interpreted the request. This evidence distinguishes investigation from authorized implementation.

Before you check the response, do you think the issue authorized investigation or implementation?

Select Activity on the issue.
Review the latest Linear Agent response in the Activity feed.
Check the issue for an attached coding session.
Check the issue for an attached draft GitHub pull request.

You will see a scoping response in the Activity feed. No coding session or draft pull request is attached.

You found the intended shortfall. The issue asked Linear Agent to investigate without giving it authority to implement a change.

Why Did Linear Agent Stop at Scoping?

Linear Coding Sessions treat requests to investigate, debug, research, plan, or create a task as scoping work. Those requests do not start coding.

A direct request to implement or open a pull request authorizes implementation. Your ticket contains only investigation language.

An implementation contract removes this ambiguity by defining the work that the agent may perform. The current ticket is missing five ingredients.

Identify the missing concrete artifact that the agent should create or change.
Identify the missing bounded scope for the work.
Identify the missing non-goals that protect unrelated files.
Identify the missing acceptance criteria that define completion.
Identify the missing validation expectations that define suitable evidence.

No Scoping Response in Activity?

Confirm that Linear Agent is still shown as the delegated agent.
Confirm that the issue belongs to a team the agent can access.
Confirm that the description still reads Investigate how we could make contributor onboarding clearer..

Still stuck? Help me diagnose why Linear Agent has not added a scoping response to this issue.

You have now seen how vague investigation language stops before implementation. Next, you will turn this request into a bounded contract that Linear Agent can reuse.

Create an Agent-Ready Ticket Skill

Your first delegation exposed the gap clearly. Linear Agent received an investigation request with no authority to implement.

An implementation contract turns vague intent into bounded work. It defines what can change before any AI credits are spent.

You'll use the stalled issue to create that contract. You'll save the successful refinement as a reusable personal skill for future tickets.

In this step, get ready to:

Refine the vague issue into an implementation contract.
Define a documentation-only target with explicit boundaries.
Add a capped agentic review loop before human review.
Save the refinement workflow as a personal skill.

Refine the issue in Linear Agent chat

Agent chat provides a safe place to expose uncertainty before an issue authorizes implementation. This refinement asks for one critical question when important context is missing.

Press Cmd+J (macOS) or Ctrl+J (Windows) to open a fresh Linear Agent chat.
Reference the Improve contributor onboarding issue in the fresh chat.
Ask Linear Agent to draft the implementation contract by pasting this prompt:

Refine this issue into an implementation-ready coding ticket. Preserve the intent. Include the problem, desired outcome, exact scope, non-goals, repository, files only when confirmed, acceptance criteria, validation expectations, and a capped agentic review loop before human review. The loop must compare the diff with the contract, run applicable checks, correct findings, rerun affected checks, and stop after two review passes. Require a report of unresolved findings. Ask one question if critical context is missing. Do not invent paths, commands, or requirements. Keep the final approval and merge human-only.

Why This Prompt Works

Preserving the intent keeps the refinement focused on contributor onboarding.
Separating scope from non-goals creates a clear boundary around the work.
Requesting confirmed repository context prevents the agent from guessing where the change belongs.
Allowing one critical question gives uncertainty a visible place in the workflow.
Requiring an agentic review loop makes the agent inspect its own diff and validation evidence before handoff.
Capping the loop at two passes limits extra AI-credit usage and exposes unresolved findings to the human reviewer.

Review the proposal for invented paths or commands.
Answer the single clarification question if Linear Agent asks one.
Apply the proposed refinement to the issue once every repository detail is confirmed.

You'll see the issue change from an investigation request into a structured implementation proposal. The proposal should expose missing context instead of filling it with assumptions.

Did the Refinement Invent Details?

Remove any unconfirmed path or command from the proposal. Ask Linear Agent to leave that detail unresolved until you provide evidence from the target repository.

Need help reviewing the proposal? Help me identify assumptions in my Linear Agent ticket refinement.

Give the issue a deterministic target

A deterministic target tells the agent exactly which artifact to produce. Clear non-goals keep the trial limited to one documentation file.

Return to the Improve contributor onboarding issue from earlier.
Keep the confirmed problem statement at the top of the issue description.
Replace the remaining contract fields by copying this content below the problem statement:

Desired outcome: Create a new root-level `AGENT_WORKFLOW.md` document for this repository.

Scope:
- Create only `AGENT_WORKFLOW.md`.
- Include sections named `Ticket readiness`, `Agent boundaries`, and `Human review`.

Non-goals:
- No source-code changes.
- No dependency changes.
- No configuration changes.
- No GitHub Actions workflow changes.

Acceptance criteria:
- Explain what makes a ticket agent-ready.
- State that the agent must stop at a draft pull request.
- State that a human reviews and merges.

Validation expectations:
- Run any existing checks that apply to documentation.
- Report any checks that are skipped or not applicable.

Agentic review loop:
- Compare the completed diff with the scope, non-goals, and acceptance criteria.
- Review the validation results for failures or missing evidence.
- Correct any findings within the approved scope.
- Rerun each affected check after a correction.
- Stop after two review passes and report any unresolved findings.
- Open a draft pull request only after the loop finishes.
- Do not approve or merge the pull request.

What Does This Contract Control?

The desired outcome names one root-level document as the deliverable.
The scope defines the exact sections that belong in the document.
The non-goals protect source code, dependencies, configuration, and GitHub Actions workflows.
The acceptance criteria preserve the human merge boundary.
The validation expectations require evidence from applicable documentation checks.
The agentic review loop compares the diff with the contract, corrects findings, and reruns affected checks before handoff.
The two-pass limit prevents an open-ended loop. Any unresolved finding remains visible for the human reviewer.

Confirm that this repository refers to the target repository connected earlier.
Inspect the updated issue description for every contract field.

The issue now names AGENT_WORKFLOW.md as the only artifact. Its scope requires Ticket readiness plus Agent boundaries plus Human review sections.

The acceptance criteria keep the agent at a draft pull request. The validation expectations plus the two-pass agentic review loop require evidence before the work reaches you.

Is a Contract Field Missing?

Compare the issue description with the contract above. Restore any missing field before saving the workflow as a skill.

Need help checking the boundary? Help me verify that this issue authorizes only the documentation change.

Save the refinement as a personal skill

The successful conversation now contains a reusable refinement method. Saving it as a personal skill lets future vague requests follow the same contract structure.

Switch back to the Linear Agent chat from earlier.
Ask Linear Agent to save the successful workflow by pasting this request:

Save this ticket-refinement workflow, including its capped agentic review loop and human-only merge boundary, as a personal skill named Agent-ready ticket.

What Gets Saved?

The skill captures the refinement method from the successful conversation. It preserves the contract fields, the two-pass agentic review loop, and the human-only merge boundary.

Keeping the skill personal gives you space to test its output. Team sharing becomes useful after the workflow is stable.

Wait for Linear Agent to confirm that the personal skill is saved.

The skill lives several levels deep in personal settings, so the path is easy to miss. Before you inspect it, which parts of the successful chat do you expect the skill to preserve?

Open Settings from the Linear workspace menu.
Select Personal.
Select Agent personalization.
Select Skills.
Select Agent-ready ticket.
Confirm the skill covers every contract field, the two-pass review loop, and the human-only merge boundary.
Return to the Improve contributor onboarding issue.
Confirm the issue still contains the documentation-only contract.

You'll see Agent-ready ticket listed as a personal skill. Its contents preserve the contract, the capped review loop, and the human gate.

The issue remains assigned to you with Linear Agent delegated. No coding session or pull request is attached yet.

Can't Find the Saved Skill?

Return to the same Linear Agent chat. Send the save request again after confirming that the conversation contains the successful refinement.

Still missing the skill? Help me troubleshoot why my Linear Agent personal skill was not saved.

You built the control point that the first request was missing. Next, Linear Agent can implement the one-file change, review its own evidence, and stop at your human gate.

Delegate the Implementation

Your Agent-ready ticket skill turned a vague request into a bounded contract in the last step. The issue now tells the agent exactly what it may change.

That clarity gives Linear Agent permission to implement without guessing.

A Linear Coding Session uses the repository environment to produce a draft pull request in GitHub. You keep the merge decision.

In this step, get ready to:

Start a Coding Session with an implementation instruction that preserves the human merge gate.
Keep the session inside the issue's one-file contract.
Follow the capped agentic review loop through corrections and rerun checks.
Confirm the completed session returns a linked draft pull request.

Start the implementation session

The refined issue now authorizes implementation. A direct request tells Linear Agent to move beyond scoping and begin repository work.

Starting this session consumes AI credits. Your repository-specific environment and one-file contract keep the work focused.

Switch back to Improve contributor onboarding in Linear.
Check that your name remains in the Assignee field.
Check that Linear Agent remains visible in the assignment menu.
Add the implementation request in a new issue comment by pasting the text below:

@Linear Implement this issue in the connected repository. Run the capped agentic review loop in the issue before handoff: compare the diff with the scope, non-goals, and acceptance criteria; inspect applicable check results; correct findings; and rerun affected checks. Stop after two review passes and report unresolved findings. Open a draft pull request only after the loop finishes, then stop for independent human review. Do not approve or merge.

What Does This Instruction Do?

The @Linear mention sends the comment to Linear Agent.
The implementation request tells the agent to begin work from the refined issue.
The review loop makes the agent compare its diff with the contract before handoff.
The correction and rerun requirements turn review findings into another tested revision.
The two-pass limit prevents an open-ended paid loop and requires unresolved findings to remain visible.
The draft pull request requirement creates a reviewable handoff.
The Do not approve or merge. instruction preserves the independent human gate.

Submit the comment.
Follow the issue's Activity feed until a Coding Session is attached.

Processing time varies with the repository and model. A quiet stretch can be normal while the session prepares the repository.

You'll see a Coding Session attached to the issue instead of another scoping-only response. That result confirms the request started implementation work.

Coding Session not starting?

Confirm the issue still names the target repository.
Confirm Linear Agent remains delegated in the assignment menu.
Confirm your comment includes the direct implementation request shown above.

Still seeing another scoping response? Help me diagnose why my implementation-ready Linear issue did not start a Coding Session.

Monitor the session without taking over

The session timeline shows whether the agent is following the issue contract. Your role is to guard the boundary while the agent performs the implementation.

Select the attached session from the issue's Activity feed.
Follow the session timeline until implementation reaches its first review pass.
Confirm the changed-file report names only root-level AGENT_WORKFLOW.md.
Inspect the first review pass for a comparison with the scope, non-goals, and acceptance criteria.
Inspect the validation report for every applicable documentation check.
Confirm each finding leads to a correction and a rerun of the affected check.
Confirm the session stops after no more than two review passes.
Confirm the final report identifies any unresolved findings before handoff.

At completion, the session should report that it changed only AGENT_WORKFLOW.md. Its final review summary should account for the contract, each applicable check, every correction, and any unresolved finding.

Session drifting beyond scope?

Redirect the session to the acceptance criteria if it proposes another file.
Reinforce the prohibition on source-code changes if it proposes implementation code.
Reinforce the prohibition on dependency or GitHub Actions workflow changes if either appears.

Need help restoring the boundary? Help me steer this Linear Coding Session back to its one-file issue contract.

Confirm the draft pull request handoff

The completed agentic review loop improves the proposal before it reaches you. The draft pull request still marks the boundary where independent human governance begins.

Before you inspect the handoff, do you expect the issue to show another scoping response or a linked draft pull request?

Return to the Improve contributor onboarding issue after the session reports completion.
Select the linked pull request after Linear attaches it to the issue.
Confirm the pull request belongs to the intended repository.
Confirm the pull request targets the repository's default branch.
Confirm the pull request remains in draft state.
Switch back to the Linear issue.
Confirm the completed session includes its agentic review report.
Confirm the report identifies any unresolved findings for human review.

You'll see a linked draft pull request for the target repository's default branch. The issue should retain its contract, the completed session, and the agentic review report.

That's the implementation handoff complete. Linear Agent has produced a reviewable proposal while the merge remains yours.

Draft pull request missing?

Confirm the Coding Session reached completion in the issue's Activity feed.
Confirm the session used the target repository's active environment.
Review the session result for a reported failure before attempting another paid run.

Still missing the handoff? Help me diagnose why my completed Linear Coding Session did not attach a draft pull request.

The agent has implemented, checked, and reviewed its proposal within the capped loop. Next, you'll independently inspect the evidence before deciding whether it merges.

Review, Validate, and Merge Manually

Your Linear Agent coding session has returned a linked draft pull request for AGENT_WORKFLOW.md after its capped review loop. The agent has stopped at the human boundary you set.

The agent's review report provides supporting evidence. Your independent diff review plus CI evidence preserves the final shipping decision.

In this step, get ready to:

Inspect the agentic review report for findings, corrections, rerun checks, and unresolved issues.
Review the draft pull request independently against the exact issue contract.
Validate the repository-required checks and confirm the change stayed within scope.
Perform the merge yourself and verify that Linear records the result.

Review the proposed change

The agentic review report shows what the session checked and corrected before handoff. You will verify that report against the actual diff instead of accepting its conclusion.

Inspect the completed session's final review report for findings, corrections, rerun checks, and unresolved issues.
Switch back to the linked draft pull request from the Linear issue.
Select Files changed.
Confirm the only changed file is the root-level AGENT_WORKFLOW.md document.
Inspect the Ticket readiness section for an explanation of what makes a ticket agent-ready.
Inspect the Agent boundaries section for the requirement to stop at a draft pull request.
Inspect the Human review section for the requirement that a human reviews and merges.
Select Viewed for the file after every requirement matches the issue contract.

The report and the diff should tell the same story: one documentation file, all three required sections, and no unresolved scope violation. Your independent comparison proves the agentic loop did not replace human judgment.

Change exceeds the issue contract?

Leave a review comment on each change that falls outside the issue contract.
Return to the attached coding session in Linear.
Ask Linear Agent to correct the pull request without widening the approved scope.

Need help identifying a scope violation? Help me compare this pull request with the Linear issue contract.

Validate the existing automation

The diff proves what changed. GitHub Actions provides separate evidence that the repository accepted the proposed change under its existing automation.

Inspect the check summary on the pull request.
Confirm every repository-required check is successful.
Select the repository's Actions tab to identify the workflow run associated with the pull request.
Select the workflow run that corresponds to this pull request.
Inspect the workflow run for its job details and step details.
Treat a skipped documentation-only check as acceptable only when repository rules do not require it.
Confirm the diff contains no dependency files or GitHub Actions workflow files.

Every required check should show a successful result. The unchanged dependency files plus workflow files confirm that the agent preserved the trial boundaries.

Required check is not successful?

Inspect the unsuccessful workflow job for the step that prevented completion.
Keep the pull request unmerged while a required check remains unsuccessful.
Ask Linear Agent to correct the documented issue without changing unrelated files.

Need help reading the workflow evidence? Help me understand why this required GitHub Actions check did not succeed.

Perform the human-only merge

A draft pull request cannot merge. Moving it to review-ready status lets you exercise the human gate after the scope and checks have passed.

Merging writes the reviewed document to the repository's default branch. You have already gathered the evidence needed to make that decision safely.

Select Ready for review in the pull request merge box.
Review the merge methods available under the repository's rules.
Choose an available merge method that complies with those rules.
Use the confirmation control to perform the merge yourself.
Delete the head branch when GitHub offers that cleanup.

Before you verify the handoff, do you expect GitHub and Linear to tell the same story?

Inspect the pull request status in GitHub.
Inspect the required-check summary on the merged pull request.

You should see Merged. Every repository-required check should remain successful.

Switch back to the Improve contributor onboarding issue in Linear.
Inspect the issue Activity feed.
Inspect the issue status.

You should see the linked merge event in the Activity feed. The issue should show the team's mapped completed status.

The completed coding session remains attached as review evidence. The repository's default branch now contains the merged AGENT_WORKFLOW.md document.

You have closed the control loop. Linear Agent implemented and reviewed the proposal, GitHub Actions tested it, and you kept the approval plus shipping decision human.

Secret mission

Prove the Skill Is Reusable

Your first ticket proved the skill once. Reuse it on a vague deployment documentation request while preserving every unresolved detail. Stop before another paid coding session begins.

Clean Up Your Resources

Choose whether to keep your Linear-to-GitHub workflow ready, pause delegation, or remove its remaining disposable resource. Inactive configuration creates no new Coding Sessions charge.

Resources you used:

The merged pull request's head branch, if it still remains after GitHub's post-merge cleanup.

Keep everything running

No action is needed. Choose this option if you plan to reuse the workflow for future agent-ready tickets.

Keep the repository-limited Linear GitHub integration available for future issues.
Keep the target-repository coding environment active with its constrained guidance.
Keep your personal Agent-ready ticket skill available for future refinements.
Preserve the completed Improve contributor onboarding issue as workflow evidence.
Preserve the successful GitHub Actions results with the merged pull request.
Review your available AI credits before starting another Coding Session.

Future Sessions Use Credits

Each new Coding Session consumes model tokens plus sandbox runtime billed at $0.25 per 20-minute block. Failed runs or partial runs can also consume credits.

Pause - I'll come back to this later

Pause new delegation while keeping the integration, environment, skill, evidence, and remaining credit balance ready for later use.

Stop delegating new issues to Linear Agent.
Leave the Make deployment documentation better. issue undelegated.
Keep the target-repository coding environment active.
Open Settings in Linear.
Select Usage & limits to check the remaining AI-credit balance.
Confirm that no new Coding Session is active.

Prepaid Credits Still Expire

Added AI-credit funds expire 12 months after purchase. They remain non-refundable and non-transferable while the workflow is paused.

Delete - I don't want to use this again

Remove the remaining disposable branch if it still exists. Keep AGENT_WORKFLOW.md on the default branch as the merged workflow record.

Protect Shared Repository Access

Removing repository access can interrupt teammates who rely on the same integration or coding environment.

Ask a Linear owner or administrator to review the Coding Sessions environment before removing it.
Ask the same administrator to review the GitHub integration before removing repository access.

Return to the merged pull request in GitHub.
Use GitHub's post-merge cleanup control if the head branch still exists.
Confirm that the head branch is no longer available from the merged pull request.
Keep AGENT_WORKFLOW.md on the target repository's default branch.
Preserve the completed Linear issue as the record of the human-gated workflow.
Preserve the completed Coding Session result as review evidence.

Removing project configuration does not refund or transfer any prepaid AI-credit balance.

Nice Work!

You did it! You built a human-gated delivery workflow that carries a Linear issue into a GitHub pull request. Linear Agent proposed the change while GitHub Actions validated it before your final merge.

You've learned how to:

Configured a controlled coding environment with repository-limited access. Its guidance protected source code, dependencies, and workflows. It required the agent to stop at a draft pull request for human review.
Experienced the scoping gap caused by a vague investigation request. You converted the issue into an implementation contract. You saved the successful refinement process as the reusable Agent-ready ticket skill.
Completed the human review gate on a linked draft pull request. You confirmed that only AGENT_WORKFLOW.md changed. You verified the required checks. You performed the repository-compliant merge yourself.
Secret Mission: Reused Agent-ready ticket to refine the second request, Make deployment documentation better. You preserved unresolved uncertainty. You stopped before starting another paid coding session.

Ready to quiz yourself?