Positron Qa Verify

Name: Positron Qa Verify
Author: posit-dev

posit-dev/positron

57 installs
4.2k repo stars
Updated August 5, 2026
posit-dev/positron

positron-qa-verify is a Claude Code skill for ai & agent building.

About

positron-qa-verify is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted coding.

positron-qa-verify
AI & Agent Building
AI-coding skill

Positron Qa Verify by the numbers

57 all-time installs (skills.sh)
+1 installs in the week ending Aug 4, 2026 (Skillselion tracking)
Ranked #6,590 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
Data as of Aug 5, 2026 (Skillselion catalog sync)

npx skills add https://github.com/posit-dev/positron --skill positron-qa-verify

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/posit-dev/positron/positron-qa-verify.svg)](https://skillselion.com/skills/posit-dev/positron/positron-qa-verify)

Installs	57
repo stars	★ 4.2k
Last updated	August 5, 2026
Repository	posit-dev/positron ↗

How do I helps with ai & agent building tasks during AI-assisted development.?

Helps with ai & agent building tasks during AI-assisted development.

Who is it for?

Best when you're working on ai & agent building and need structured help with positron qa verify.

Skip if: Teams with no ai & agent building needs, or anyone wanting a generic chat assistant without this specific workflow.

When should I use this skill?

When you need to helps with ai & agent building tasks during AI-assisted development., or when positron-qa-verify is a claude code skill for ai & agent building.

What you get

Structured output aligned to positron-qa-verify: positron-qa-verify, AI & Agent Building.

Files

SKILL.mdMarkdownGitHub ↗

Positron QA Verify

Analyzes GitHub issues and PRs to generate verification guides for manual QA testing.

When to Use

Assigned a ticket from the QA verification board (https://github.com/orgs/posit-dev/projects/2/views/8)
Need test scenarios for a bug fix or feature
Want to extract edge cases from issue comments and PR discussions

Prerequisites

GitHub CLI (gh) authenticated
Working in the Positron repository

Execution Mode

CRITICAL: Run non-interactively without prompts.

Never use `AskUserQuestion` - Always write to .claude/skills/positron-qa-verify/output/
Version detection is best-effort - If it fails, use empty values silently
Fail fast - Don't block on timeouts or missing data

Input

Issue number or URL:

4567
#4567
https://github.com/posit-dev/positron/issues/4567

Workflow

Steps 1 & 2: Fetch Issue and Find PRs (Parallel)

Run these in parallel with a single message containing multiple Bash tool calls:

gh issue view <number> --repo posit-dev/positron --json title,body,comments,url,labels,author
gh pr list --repo posit-dev/positron --search "<number>" --state all --json number,title

Step 3: Analyze PR Context

Fetch primary PR details:

gh pr view <pr-number> --repo posit-dev/positron --json title,body,comments,additions,deletions,url

Fetch all related PRs/issues mentioned in the body in parallel.

Step 4: Review Code Changes (Conditional)

Only for PRs < 500 lines (additions + deletions from Step 3):

gh pr diff <pr-number> --repo posit-dev/positron

Skip diff for large PRs - use PR description and comments instead.

Step 5: Extract Linked Issues

Search comments for #1234 references, additional test scenarios, edge cases, and platform-specific notes.

Step 6: Generate Verification Guide

Create markdown file in .claude/skills/positron-qa-verify/output/verify-issue-{number}-{timestamp}.md

See references/verification_guide.md for format and examples.

Step 7: Offer Verification Comment Template

After generating the guide, offer to create a verification comment template.

Only when user accepts: 1. Run scripts/detect_versions.sh to auto-detect Positron and OS versions 2. Generate comment template with scenarios from the guide 3. Copy to clipboard

Comment format:

Single scenario (no edge cases/regressions): Simple bullet format
Multiple scenarios: Grouped format with Primary/Edge cases/Regression checks sections

Output

.claude/skills/positron-qa-verify/output/verify-issue-{number}-{timestamp}.md

Helper Scripts

`scripts/detect_versions.sh`

Fast, silent version detection (max 4 seconds):

./scripts/detect_versions.sh

Output:

{
  "positronVersion": "2026.02.0",
  "positronBuild": "10",
  "osVersion": "macOS 26.2",
  "detectionStatus": "success"
}

Never prompts or shows errors - returns empty values on failure.

Verification Guide Reference

Core Principles

1. Be actionable - Every scenario should be testable 2. Be specific - No vague instructions like "test the feature" 3. Be complete - Cover main scenario, edge cases, and regressions 4. Be concise - No fluff

Formatting Convention

Scenario titles: Checkmarks ✓ **Title** for visual organization
Test steps: Checkboxes - [ ] Step for tracking progress
Verification comments: Plain bullets (no checkmarks/checkboxes)

Guide Structure

# Verification Guide
### [Issue Title]<br>
**Issue:** [#number](url)<br>
**Type:** Bug | Feature | Documentation | Maintenance<br>
**Primary PR:** [#number](url)<br>
**Component:** [area label]<br>
**Generated:** [timestamp]<br>

---

## Issue Summary

#### What Was Broken (bugs) / What Changed (features)
[2-3 sentences]

#### User Impact
- [Impact point 1]
- [Impact point 2]

## Root Cause (Bugs Only)

[1-2 sentences if identifiable from PR]

## Test Scenarios

### Primary Scenario

✓ **[Scenario title]**

**Setup:** (if needed)
- [ ] Setup step

**Test Steps:**
- [ ] Step one
- [ ] Step two

**Expected:** [What should happen]
**Previously:** [What was broken]

### Edge Cases

✓ **[Edge case title]**

**_Why test:_** [Brief explanation]

- [ ] Step one
- [ ] Step two

### Regression Checks

- [ ] [What to verify]
- [ ] [Another check]

## Testing Context

**Environment:**
- Positron version: [if specified]
- OS: [if relevant]
- Language: Python/R [version if specified]

**Setup:**
[Required setup steps]

**Related PRs:**
- [Links with brief descriptions]

## References

- Issue: [link]
- PR: [link]
- Related: [links]

---
*Generated by positron-qa-verify skill*

Extracting Test Scenarios

From comments, look for:

"Also happens when..."
"Same issue with..."
"Edge case: ..."
"What about...?"

From PR descriptions, look for:

"This also fixes..."
"Note that..."
Testing notes or QA sections

From code diffs (small PRs only):

Which files changed (affected areas)
Test files added/modified
Configuration changes

Verification Comment Templates

Single Scenario (simple format)

Use when there's truly only 1 test and no edge cases/regressions:

### Verified Fixed
Positron Version(s): [version]
OS Version(s): [OS]

### Test scenario(s)
- [Single scenario]

### Link(s) to test cases run or created:
[links or n/a]

Multiple Scenarios (grouped format - default)

Use for 2+ scenarios or any edge cases/regressions:

### Verified Fixed
Positron Version(s): [version]
OS Version(s): [OS]

### Test scenario(s)

**Primary scenario:**
- [Main test]

**Edge cases:**
- [Edge case 1]
- [Edge case 2]

**Regression checks:**
- [Regression 1]
- [Regression 2]

### Link(s) to test cases run or created:
[links or n/a]

Example: Bug Fix

# Verification Guide
### Console crashes when printing None in Python<br>
**Issue:** [#4567](https://github.com/posit-dev/positron/issues/4567)<br>
**Type:** Bug<br>
**Primary PR:** [#4589](https://github.com/posit-dev/positron/pull/4589)<br>
**Component:** Console<br>

---

## Issue Summary

#### What Was Broken
Printing `None` in the Python console causes Positron to crash.

#### User Impact
- Console unusable for common debugging workflows
- Any code that prints None values affected

## Root Cause

Console output renderer didn't handle None values, attempting to call .toString() on undefined.

## Test Scenarios

### Primary Scenario

✓ **Print None in console**

**Test Steps:**
- [ ] Open Positron with Python
- [ ] In console, type: `print(None)`
- [ ] Press Enter

**Expected:** Console prints "None" and remains functional
**Previously:** Positron crashed

### Edge Cases

✓ **None in variables**

**_Why test:_** Ensures fix handles indirect None values

- [ ] Run: `x = None; print(x)`

✓ **None in collections**

**_Why test:_** Tests serialization of None in complex structures

- [ ] Run: `print([1, None, 3])`

### Regression Checks

- [ ] Printing other falsy values works (0, False, "", [])
- [ ] Normal printing still works
- [ ] Console error handling works for real errors

## Testing Context

**Environment:**
- Python 3.x (any version)

## References

- Issue: https://github.com/posit-dev/positron/issues/4567
- PR: https://github.com/posit-dev/positron/pull/4589

Example: Feature

# Verification Guide
### Add keyboard shortcut for running selected code<br>
**Issue:** [#3456](https://github.com/posit-dev/positron/issues/3456)<br>
**Type:** Feature<br>
**Primary PR:** [#3478](https://github.com/posit-dev/positron/pull/3478)<br>
**Component:** Editor<br>

---

## Issue Summary

#### What Changed
Users can now run selected code using Cmd+Enter (Ctrl+Enter on Windows/Linux).

#### User Impact
- Running code snippets is faster
- No need to use right-click menu or Run menu

## Test Scenarios

### Primary Scenario

✓ **Run selected code with shortcut**

**Test Steps:**
- [ ] Open a Python or R file
- [ ] Select a few lines of code
- [ ] Press Cmd+Enter (or Ctrl+Enter)

**Expected:** Selected code runs in the console

### Edge Cases

✓ **Single line (cursor only)**

**_Why test:_** Common usage pattern

- [ ] Click in a line without selecting
- [ ] Press Cmd+Enter
- [ ] Verify current line runs

✓ **No active console**

**_Why test:_** Edge case from PR review

- [ ] Close all console sessions
- [ ] Select code and press Cmd+Enter
- [ ] Verify new console starts and code runs

### Regression Checks

- [ ] Run menu still works
- [ ] Right-click context menu still works
- [ ] Cmd+Enter in console REPL unchanged

## Testing Context

**Environment:**
- Test with both Python and R files

## References

- Issue: https://github.com/posit-dev/positron/issues/3456
- PR: https://github.com/posit-dev/positron/pull/3478

#!/bin/bash
# detect_versions.sh - Fast, silent version detection for Positron and OS
#
# This script attempts to auto-detect:
# 1. Positron version and build number
# 2. OS version
#
# DESIGN PRINCIPLES:
# - Fast: Each detection has a 3-second timeout, max 6 seconds total
# - Silent: Never prints errors, never prompts, only outputs JSON
# - Fail-safe: If detection fails, returns empty values (not errors)
# - Cross-platform: Works on macOS, Linux, Windows (Git Bash/PowerShell)
#
# Output format: JSON with keys:
# - positronVersion: string or empty
# - positronBuild: string or empty
# - osVersion: string or empty
# - detectionStatus: "success", "partial", or "failed"

set +e  # Don't exit on errors
set -u  # But do error on undefined variables
set -o pipefail

# Timeout for each detection attempt (seconds)
TIMEOUT=2

# Colors for debug output (only used if DEBUG=1)
if [ "${DEBUG:-0}" = "1" ]; then
	RED='\033[0;31m'
	GREEN='\033[0;32m'
	YELLOW='\033[1;33m'
	NC='\033[0m'
else
	RED=''
	GREEN=''
	YELLOW=''
	NC=''
fi

debug() {
	if [ "${DEBUG:-0}" = "1" ]; then
		echo -e "${YELLOW}[DEBUG]${NC} $1" >&2
	fi
}

# Detect platform
detect_platform() {
	case "$(uname -s)" in
		Darwin*) echo "macos" ;;
		Linux*) echo "linux" ;;
		CYGWIN*|MINGW*|MSYS*) echo "windows" ;;
		*) echo "unknown" ;;
	esac
}

PLATFORM=$(detect_platform)
debug "Platform: $PLATFORM"

# Function to run command with timeout (silent on failure)
run_with_timeout() {
	local timeout=$1
	shift
	local cmd="$@"

	debug "Running: $cmd"

	# Try with timeout command if available, otherwise just run directly
	if command -v timeout >/dev/null 2>&1; then
		timeout "$timeout" bash -c "$cmd" 2>/dev/null
	elif command -v gtimeout >/dev/null 2>&1; then
		# macOS with coreutils installed
		gtimeout "$timeout" bash -c "$cmd" 2>/dev/null
	else
		# No timeout available, just run directly (risky but better than nothing)
		eval "$cmd" 2>/dev/null
	fi
	return $?
}

# Detect Positron version
detect_positron_version() {
	local product_json=""
	local positron_version=""
	local positron_build=""

	# List of paths to check (in order of likelihood)
	case "$PLATFORM" in
		macos)
			paths=(
				"/Applications/Positron.app/Contents/Resources/app/product.json"
				"$HOME/Applications/Positron.app/Contents/Resources/app/product.json"
			)
			;;
		linux)
			paths=(
				"/usr/share/positron/resources/app/product.json"
				"/opt/positron/resources/app/product.json"
				"$HOME/.local/share/positron/resources/app/product.json"
				"$HOME/positron/resources/app/product.json"
			)
			;;
		windows)
			# Convert Windows paths for Git Bash/MSYS
			localappdata="${LOCALAPPDATA:-$HOME/AppData/Local}"
			programfiles="${PROGRAMFILES:-/c/Program Files}"
			programfilesx86="${PROGRAMFILES(X86):-/c/Program Files (x86)}"

			paths=(
				"$localappdata/Programs/Positron/resources/app/product.json"
				"$programfiles/Positron/resources/app/product.json"
				"$programfilesx86/Positron/resources/app/product.json"
			)
			;;
		*)
			paths=()
			;;
	esac

	# Try each path with timeout
	for path in "${paths[@]}"; do
		debug "Checking path: $path"

		# Check if file exists quickly (no timeout needed)
		if [ -f "$path" ]; then
			debug "File exists, reading..."

			# Read and parse JSON with timeout
			if command -v jq >/dev/null 2>&1; then
				local result=$(run_with_timeout $TIMEOUT "cat '$path' | jq -r '{positronVersion:.positronVersion, positronBuildNumber:.positronBuildNumber}'")

				if [ $? -eq 0 ] && [ -n "$result" ]; then
					positron_version=$(echo "$result" | jq -r '.positronVersion // empty' 2>/dev/null)
					positron_build=$(echo "$result" | jq -r '.positronBuildNumber // empty' 2>/dev/null)

					if [ -n "$positron_version" ] && [ "$positron_version" != "null" ]; then
						debug "Found version: $positron_version build $positron_build"
						break
					fi
				fi
			else
				# Fallback: try to extract without jq (less reliable)
				local result=$(run_with_timeout $TIMEOUT "grep -E 'positronVersion|positronBuildNumber' '$path' | head -2")

				if [ $? -eq 0 ] && [ -n "$result" ]; then
					positron_version=$(echo "$result" | grep positronVersion | sed -E 's/.*"positronVersion"[^"]*"([^"]+)".*/\1/' | head -1)
					positron_build=$(echo "$result" | grep positronBuildNumber | sed -E 's/.*"positronBuildNumber"[^"]*"?([^",]+)"?.*/\1/' | head -1)

					if [ -n "$positron_version" ]; then
						debug "Found version (no jq): $positron_version build $positron_build"
						break
					fi
				fi
			fi
		fi
	done

	# Output results (even if empty)
	echo "$positron_version"
	echo "$positron_build"
}

# Detect OS version
detect_os_version() {
	local os_version=""

	case "$PLATFORM" in
		macos)
			debug "Detecting macOS version..."
			os_version=$(run_with_timeout $TIMEOUT "sw_vers -productVersion 2>/dev/null | head -1")
			if [ -n "$os_version" ]; then
				os_version="macOS $os_version"
			fi
			;;
		linux)
			debug "Detecting Linux version..."
			# Try /etc/os-release first (standard)
			if [ -f /etc/os-release ]; then
				local name=$(run_with_timeout $TIMEOUT "grep -E '^NAME=' /etc/os-release | cut -d'=' -f2 | tr -d '\"' | head -1")
				local version=$(run_with_timeout $TIMEOUT "grep -E '^VERSION_ID=' /etc/os-release | cut -d'=' -f2 | tr -d '\"' | head -1")

				if [ -n "$name" ]; then
					os_version="$name"
					if [ -n "$version" ]; then
						os_version="$os_version $version"
					fi
				fi
			fi

			# Fallback to uname
			if [ -z "$os_version" ]; then
				os_version=$(run_with_timeout $TIMEOUT "uname -sr 2>/dev/null")
			fi
			;;
		windows)
			debug "Detecting Windows version..."
			# Try multiple methods for Windows

			# Method 1: PowerShell command (if available)
			if command -v powershell.exe >/dev/null 2>&1; then
				local win_version=$(run_with_timeout $TIMEOUT "powershell.exe -NoProfile -Command '[System.Environment]::OSVersion.VersionString' 2>/dev/null | tr -d '\r'")
				if [ -n "$win_version" ]; then
					os_version="$win_version"
				fi
			fi

			# Method 2: Try systeminfo (slower, skip if we have version)
			if [ -z "$os_version" ] && command -v systeminfo >/dev/null 2>&1; then
				local win_name=$(run_with_timeout $TIMEOUT "systeminfo 2>/dev/null | grep -E 'OS Name' | cut -d':' -f2 | sed 's/^[[:space:]]*//' | head -1")
				if [ -n "$win_name" ]; then
					os_version="$win_name"
				fi
			fi

			# Fallback: uname (less informative on Windows)
			if [ -z "$os_version" ]; then
				os_version=$(run_with_timeout $TIMEOUT "uname -sr 2>/dev/null")
			fi
			;;
		*)
			os_version=$(run_with_timeout $TIMEOUT "uname -sr 2>/dev/null")
			;;
	esac

	# Trim whitespace
	os_version=$(echo "$os_version" | xargs 2>/dev/null)

	debug "OS Version: $os_version"
	echo "$os_version"
}

# Main detection logic
main() {
	debug "Starting version detection..."

	# Detect Positron version (returns two lines)
	local positron_output=$(detect_positron_version)
	local positron_version=$(echo "$positron_output" | sed -n '1p')
	local positron_build=$(echo "$positron_output" | sed -n '2p')

	# Detect OS version
	local os_version=$(detect_os_version)

	# Determine detection status
	local status="failed"
	if [ -n "$positron_version" ] && [ -n "$os_version" ]; then
		status="success"
	elif [ -n "$positron_version" ] || [ -n "$os_version" ]; then
		status="partial"
	fi

	# Output JSON (always valid, even if empty)
	cat <<-EOF
	{
	  "positronVersion": "${positron_version:-}",
	  "positronBuild": "${positron_build:-}",
	  "osVersion": "${os_version:-}",
	  "detectionStatus": "$status"
	}
	EOF

	debug "Detection complete: $status"
}

# Run main function
main

Related skills

Setup Matt Pocock SkillsScaffold the per-repo configuration that Matt Pocock’s engineering agent skills rely on so they understand the issue tracker, triage labels, and domain documentation la495k196k

Lark AppsConnect Claude, Cursor or custom agents directly to Lark (Feishu) for messaging, document automation, approval workflows and enterprise data access.402k

CavemanSlash token usage by roughly 75% while keeping every technical detail intact when working with Claude Code, Cursor or similar agents.391k94.7k

Lark Skill MakerQuickly turn any Lark/Feishu OpenAPI call or multi-step workflow into a reusable agent skill with its own SKILL.md.386k16k

Running Claude Code Via Litellm CopilotRun Claude Code at a fraction of the cost by routing requests through LiteLLM to the GitHub Copilot Chat API.270k72

Codex PetGenerate a complete Codex Pet spritesheet and metadata from one reference image without needing an OpenAI key or Codex Pro.246k10

FAQ

What does positron-qa-verify do?