diff --git a/docs/README.instructions.md b/docs/README.instructions.md
index 97cdcb082..f35ac8fe2 100644
--- a/docs/README.instructions.md
+++ b/docs/README.instructions.md
@@ -158,6 +158,7 @@ See [CONTRIBUTING.md](../CONTRIBUTING.md#adding-instructions) for guidelines on
| [PowerShell Pester v5 Testing Guidelines](../instructions/powershell-pester-5.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpowershell-pester-5.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpowershell-pester-5.instructions.md) | PowerShell Pester testing best practices based on Pester v5 conventions |
| [Project Context](../instructions/moodle.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fmoodle.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fmoodle.instructions.md) | Instructions for GitHub Copilot to generate code in a Moodle project context. |
| [Python MCP Server Development](../instructions/python-mcp-server.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpython-mcp-server.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpython-mcp-server.instructions.md) | Instructions for building Model Context Protocol (MCP) servers using the Python SDK |
+| [Python Property Testing with Hypothesis](../instructions/python-property-testing-hypothesis.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpython-property-testing-hypothesis.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fpython-property-testing-hypothesis.instructions.md) | Best practices for property-based testing in Python using Hypothesis framework |
| [Quarkus](../instructions/quarkus.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fquarkus.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fquarkus.instructions.md) | Quarkus development standards and instructions |
| [Quarkus MCP Server](../instructions/quarkus-mcp-server-sse.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fquarkus-mcp-server-sse.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fquarkus-mcp-server-sse.instructions.md) | Quarkus and MCP Server with HTTP SSE transport development standards and instructions |
| [R Programming Language Instructions](../instructions/r.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fr.instructions.md)
[](https://aka.ms/awesome-copilot/install/instructions?url=vscode-insiders%3Achat-instructions%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Finstructions%2Fr.instructions.md) | R language and document formats (R, Rmd, Quarto): coding standards and Copilot guidance for idiomatic, safe, and consistent code generation. |
diff --git a/docs/README.skills.md b/docs/README.skills.md
index 400eb0554..80371e337 100644
--- a/docs/README.skills.md
+++ b/docs/README.skills.md
@@ -246,6 +246,7 @@ See [CONTRIBUTING.md](../CONTRIBUTING.md#adding-skills) for guidelines on how to
| [prompt-builder](../skills/prompt-builder/SKILL.md) | Guide users through creating high-quality GitHub Copilot prompts with proper structure, tools, and best practices. | None |
| [publish-to-pages](../skills/publish-to-pages/SKILL.md) | Publish presentations and web content to GitHub Pages. Converts PPTX, PDF, HTML, or Google Slides to a live GitHub Pages URL. Handles repo creation, file conversion, Pages enablement, and returns the live URL. Use when the user wants to publish, deploy, or share a presentation or HTML file via GitHub Pages. | `scripts/convert-pdf.py`
`scripts/convert-pptx.py`
`scripts/publish.sh` |
| [pytest-coverage](../skills/pytest-coverage/SKILL.md) | Run pytest tests with coverage, discover lines missing coverage, and increase coverage to 100%. | None |
+| [python-hypothesis-property-testing](../skills/python-hypothesis-property-testing/SKILL.md) | Generate and optimize property-based tests for Python using Hypothesis framework with strategies, stateful testing, and test migration patterns. | None |
| [python-mcp-server-generator](../skills/python-mcp-server-generator/SKILL.md) | Generate a complete MCP server project in Python with tools, resources, and proper configuration | None |
| [python-pypi-package-builder](../skills/python-pypi-package-builder/SKILL.md) | End-to-end skill for building, testing, linting, versioning, and publishing a production-grade Python library to PyPI. Covers all four build backends (setuptools+setuptools_scm, hatchling, flit, poetry), PEP 440 versioning, semantic versioning, dynamic git-tag versioning, OOP/SOLID design, type hints (PEP 484/526/544/561), Trusted Publishing (OIDC), and the full PyPA packaging flow. Use for: creating Python packages, pip-installable SDKs, CLI tools, framework plugins, pyproject.toml setup, py.typed, setuptools_scm, semver, mypy, pre-commit, GitHub Actions CI/CD, or PyPI publishing. | `references/architecture-patterns.md`
`references/ci-publishing.md`
`references/community-docs.md`
`references/library-patterns.md`
`references/pyproject-toml.md`
`references/release-governance.md`
`references/testing-quality.md`
`references/tooling-ruff.md`
`references/versioning-strategy.md`
`scripts/scaffold.py` |
| [quality-playbook](../skills/quality-playbook/SKILL.md) | Explore any codebase from scratch and generate six quality artifacts: a quality constitution (QUALITY.md), spec-traced functional tests, a code review protocol with regression test generation, an integration testing protocol, a multi-model spec audit (Council of Three), and an AI bootstrap file (AGENTS.md). Includes state machine completeness analysis and missing safeguard detection. Works with any language (Python, Java, Scala, TypeScript, Go, Rust, etc.). Use this skill whenever the user asks to set up a quality playbook, generate functional tests from specifications, create a quality constitution, build testing protocols, audit code against specs, or establish a repeatable quality system for a project. Also trigger when the user mentions 'quality playbook', 'spec audit', 'Council of Three', 'fitness-to-purpose', 'coverage theater', or wants to go beyond basic test generation to build a full quality system grounded in their actual codebase. | `LICENSE.txt`
`references/constitution.md`
`references/defensive_patterns.md`
`references/functional_tests.md`
`references/review_protocols.md`
`references/schema_mapping.md`
`references/spec_audit.md`
`references/verification.md` |
diff --git a/instructions/python-property-testing-hypothesis.instructions.md b/instructions/python-property-testing-hypothesis.instructions.md
new file mode 100644
index 000000000..b0c3b621c
--- /dev/null
+++ b/instructions/python-property-testing-hypothesis.instructions.md
@@ -0,0 +1,186 @@
+---
+description: 'Best practices for property-based testing in Python using Hypothesis framework'
+applyTo: '**/test_*.py, **/*_test.py, **/tests/**/*.py'
+---
+
+# Python Property Testing with Hypothesis
+
+Use property-based testing to discover edge cases automatically by testing universal properties instead of specific examples.
+
+## Installation
+
+```bash
+pip install "hypothesis[cli]"
+```
+
+## Configuration
+
+```python
+# conftest.py
+from hypothesis import settings
+import os
+
+settings.register_profile("dev", max_examples=100)
+settings.register_profile("ci", max_examples=1000)
+settings.load_profile(os.getenv("HYPOTHESIS_PROFILE", "dev"))
+```
+
+```ini
+# pytest.ini
+[pytest]
+markers = property: Property-based tests
+hypothesis-show-statistics = true
+```
+
+## Common Property Patterns
+
+```python
+from hypothesis import given, strategies as st, example
+
+# Idempotency: f(f(x)) == f(x)
+@given(st.lists(st.integers()))
+def test_reverse_twice(xs):
+ assert reverse(reverse(xs)) == xs
+
+# Round-trip: decode(encode(x)) == x
+@given(st.dictionaries(st.text(), st.integers()))
+def test_json_roundtrip(data):
+ assert json.loads(json.dumps(data)) == data
+
+# Invariant: property always holds
+@given(st.lists(st.integers(), min_size=1))
+def test_max_in_list(xs):
+ assert max(xs) in xs
+
+# Oracle: compare with known implementation
+@given(st.lists(st.integers()))
+def test_sort_matches_builtin(xs):
+ assert custom_sort(xs) == sorted(xs)
+
+# Commutativity: f(a, b) == f(b, a)
+@given(st.integers(), st.integers())
+def test_addition_commutative(a, b):
+ assert a + b == b + a
+```
+
+## Strategies
+
+```python
+# Built-in strategies
+st.integers(min_value=0, max_value=100)
+st.text(min_size=1, max_size=100)
+st.lists(st.integers(), max_size=50)
+st.dictionaries(st.text(), st.integers())
+st.dates(min_value=date(2000, 1, 1))
+st.emails()
+
+# Composite strategies
+from hypothesis.strategies import composite
+
+@composite
+def user_strategy(draw):
+ return User(
+ username=draw(st.text(min_size=3)),
+ age=draw(st.integers(min_value=18, max_value=120)),
+ email=draw(st.emails())
+ )
+```
+
+## Stateful Testing
+
+```python
+from hypothesis.stateful import RuleBasedStateMachine, rule, invariant
+
+class StackMachine(RuleBasedStateMachine):
+ def __init__(self):
+ super().__init__()
+ self.stack = []
+
+ @rule(value=st.integers())
+ def push(self, value):
+ self.stack.append(value)
+
+ @rule()
+ def pop(self):
+ if self.stack:
+ self.stack.pop()
+
+ @invariant()
+ def size_non_negative(self):
+ assert len(self.stack) >= 0
+
+TestStack = StackMachine.TestCase
+```
+
+## Migration from Example Tests
+
+```python
+# Keep critical edge cases
+@given(st.lists(st.integers()))
+@example([]) # Empty
+@example([1]) # Single
+@example([1, 1, 1]) # Duplicates
+def test_sort(xs):
+ result = sort(xs)
+ assert sorted(result) == sorted(xs)
+```
+
+## Debugging
+
+```python
+from hypothesis import seed, note
+
+# Reproduce failure
+@seed(1234567890) # From failure output
+@given(st.integers())
+def test_reproduce(x):
+ note(f"Input: {x}")
+ assert process(x) is not None
+```
+
+## Settings
+
+```python
+from hypothesis import settings
+from datetime import timedelta
+
+@settings(
+ max_examples=50,
+ deadline=timedelta(milliseconds=100)
+)
+@given(st.lists(st.integers()))
+def test_with_settings(xs):
+ assert process(xs) is not None
+```
+
+## Best Practices
+
+**DO:**
+- Test universal properties, not specific examples
+- Use strategy constraints over `assume()`
+- Keep critical edge cases with `@example()`
+- Run CI with `max_examples=1000`
+
+**AVOID:**
+- Test implementation details
+- Use `random.random()` (breaks reproducibility)
+- Over-use `assume()` (prefer constraints)
+
+## Common Patterns
+
+```python
+# Prefer strategy constraints
+@given(st.integers().map(lambda x: x * 2))
+def test_even(n):
+ assert n % 2 == 0
+
+# Avoid heavy filtering
+@given(st.integers())
+def test_even_bad(n):
+ assume(n % 2 == 0) # Not recommended
+```
+
+## Resources
+
+- [Hypothesis Documentation](https://hypothesis.readthedocs.io/)
+- [Property-Based Testing Guide](https://fsharpforfunandprofit.com/posts/property-based-testing/)
diff --git a/skills/python-hypothesis-property-testing/SKILL.md b/skills/python-hypothesis-property-testing/SKILL.md
new file mode 100644
index 000000000..b76308d90
--- /dev/null
+++ b/skills/python-hypothesis-property-testing/SKILL.md
@@ -0,0 +1,317 @@
+---
+name: python-hypothesis-property-testing
+description: 'Generate and optimize property-based tests for Python using Hypothesis framework with strategies, stateful testing, and test migration patterns.'
+---
+
+# Python Property Testing with Hypothesis
+
+Use property-based testing to automatically discover edge cases by testing universal properties rather than specific examples.
+
+## When to Use
+
+- Generate property tests from existing code
+- Migrate example-based tests to property tests
+- Test systems with complex state transitions
+- Create custom strategies for domain models
+- Debug and optimize property tests
+
+## Installation
+
+```bash
+pip install "hypothesis[cli]"
+
+# With optional extras
+pip install "hypothesis[numpy,pandas,django]"
+```
+
+## Core Concepts
+
+### Property vs Example Tests
+
+**Example-based** (specific):
+```python
+def test_sort_specific():
+ assert sort([3, 1, 2]) == [1, 2, 3]
+```
+
+**Property-based** (universal):
+```python
+from hypothesis import given, strategies as st
+
+@given(st.lists(st.integers()))
+def test_sort_property(xs):
+ """Sorted output contains same elements."""
+ result = sort(xs)
+ assert sorted(result) == sorted(xs)
+ assert len(result) == len(xs)
+```
+
+## Common Property Patterns
+
+### 1. Idempotency
+```python
+@given(st.lists(st.integers()))
+def test_reverse_twice_is_identity(xs):
+ """f(f(x)) == x"""
+ assert reverse(reverse(xs)) == xs
+```
+
+### 2. Round-Trip
+```python
+@given(st.dictionaries(st.text(), st.integers()))
+def test_json_roundtrip(data):
+ """encode(decode(x)) == x"""
+ assert json.loads(json.dumps(data)) == data
+```
+
+### 3. Invariants
+```python
+@given(st.lists(st.integers(), min_size=1))
+def test_max_in_list(xs):
+ """max(xs) is always in xs"""
+ assert max(xs) in xs
+```
+
+### 4. Commutativity
+```python
+@given(st.integers(), st.integers())
+def test_addition_commutative(a, b):
+ """a + b == b + a"""
+ assert a + b == b + a
+```
+
+### 5. Oracle Comparison
+```python
+@given(st.lists(st.integers()))
+def test_custom_sort_matches_builtin(xs):
+ """Compare with known-good implementation"""
+ assert custom_sort(xs) == sorted(xs)
+```
+
+## Strategy Selection
+
+| Type | Strategy | Use Case |
+|------|----------|----------|
+| Integers | `st.integers(min_value=0, max_value=100)` | IDs, ages |
+| Text | `st.text(min_size=1, max_size=100)` | Usernames |
+| Lists | `st.lists(st.integers(), max_size=50)` | Collections |
+| Dicts | `st.dictionaries(st.text(), st.integers())` | Config |
+| Dates | `st.dates(min_value=date(2000, 1, 1))` | Timestamps |
+| Emails | `st.emails()` | Email addresses |
+
+## Custom Strategies
+
+### Composite Strategy
+```python
+from hypothesis.strategies import composite
+
+@composite
+def user_strategy(draw):
+ """Generate valid User instances."""
+ return User(
+ username=draw(st.text(min_size=3, max_size=20)),
+ age=draw(st.integers(min_value=18, max_value=120)),
+ email=draw(st.emails())
+ )
+
+@given(user_strategy())
+def test_user_validation(user):
+ assert 18 <= user.age <= 120
+```
+
+### Using st.builds()
+```python
+user_strategy = st.builds(
+ User,
+ username=st.text(min_size=3, max_size=20),
+ age=st.integers(min_value=18, max_value=120),
+ email=st.emails()
+)
+```
+
+## Stateful Testing
+
+Test systems with complex state:
+
+```python
+from hypothesis.stateful import RuleBasedStateMachine, rule, invariant
+
+class StackStateMachine(RuleBasedStateMachine):
+ def __init__(self):
+ super().__init__()
+ self.stack = []
+
+ @rule(value=st.integers())
+ def push(self, value):
+ self.stack.append(value)
+
+ @rule()
+ def pop(self):
+ if self.stack:
+ self.stack.pop()
+
+ @invariant()
+ def size_non_negative(self):
+ assert len(self.stack) >= 0
+
+TestStack = StackStateMachine.TestCase
+```
+
+## Configuration
+
+### conftest.py
+```python
+from hypothesis import settings, Verbosity
+import os
+
+settings.register_profile("dev", max_examples=100)
+settings.register_profile("ci", max_examples=1000, verbosity=Verbosity.verbose)
+settings.load_profile(os.getenv("HYPOTHESIS_PROFILE", "dev"))
+```
+
+### pytest.ini
+```ini
+[pytest]
+markers =
+ property: Property-based tests
+
+hypothesis-show-statistics = true
+```
+
+## Migrating Example Tests
+
+**Incremental approach:**
+
+```python
+# Step 1: Add property test alongside examples
+@given(st.lists(st.integers()))
+@example([]) # Keep critical edge cases
+@example([1])
+@example([1, 1, 1])
+def test_sort_comprehensive(xs):
+ result = sort(xs)
+ assert sorted(result) == sorted(xs)
+
+# Step 2: Remove redundant example tests once property test passes
+```
+
+## Debugging Failed Tests
+
+When Hypothesis finds a failing case:
+
+```python
+# Hypothesis output shows:
+# Falsifying example: test_function(x=42)
+# Reproduce with: @seed(1234567890)
+
+from hypothesis import seed
+
+@seed(1234567890) # Use seed from failure
+@given(st.integers())
+def test_reproduce(x):
+ assert process(x) is not None
+```
+
+**Debug helpers:**
+```python
+from hypothesis import note, event
+
+@given(st.lists(st.integers()))
+def test_with_debug(xs):
+ note(f"Input: {xs}")
+ note(f"Length: {len(xs)}")
+ result = process(xs)
+ event(f"Result size: {len(result)}")
+```
+
+## Settings and Optimization
+
+```python
+from hypothesis import settings
+from datetime import timedelta
+
+@settings(
+ max_examples=50, # Reduce for faster tests
+ deadline=timedelta(milliseconds=100), # Performance threshold
+)
+@given(st.lists(st.integers()))
+def test_optimized(xs):
+ assert process(xs) is not None
+```
+
+## Best Practices
+
+**DO:**
+- Test universal properties, not specific examples
+- Use strategy constraints instead of `assume()`
+- Keep critical edge cases with `@example()`
+- Commit `.hypothesis/examples.db` for regression testing
+- Run CI with `max_examples=1000`
+
+**AVOID:**
+- Test implementation details
+- Use `random.random()` (breaks reproducibility)
+- Over-use `assume()` (prefer strategy constraints)
+- Ignore all exceptions
+- Test single specific values
+
+## Common Issues
+
+### "Too much filtering"
+```python
+# Bad - heavy filtering
+@given(st.integers())
+def test_even(n):
+ assume(n % 2 == 0)
+
+# Better - strategy constraints
+@given(st.integers().map(lambda x: x * 2))
+def test_even(n):
+ assert n % 2 == 0
+```
+
+### "Non-deterministic test"
+```python
+# Bad - uses random
+@given(st.integers())
+def test_random(n):
+ if random.random() > 0.5: # Non-deterministic!
+ assert n > 0
+
+# Better - deterministic
+@given(st.integers(), st.booleans())
+def test_deterministic(n, condition):
+ if condition:
+ assert n > 0
+```
+
+## CI Integration
+
+```yaml
+# .github/workflows/tests.yml
+- name: Run property tests
+ run: pytest -m property --hypothesis-profile=ci
+ env:
+ HYPOTHESIS_PROFILE: ci
+```
+
+## Quick Reference
+
+```bash
+# Run property tests
+pytest -m property
+
+# Run with CI profile
+pytest -m property --hypothesis-profile=ci
+
+# Reproduce failure
+pytest --hypothesis-seed=1234567890
+
+# Show statistics
+pytest -m property --hypothesis-show-statistics
+```
+
+## Resources
+
+- [Hypothesis Documentation](https://hypothesis.readthedocs.io/)
+- [Property-Based Testing Guide](https://fsharpforfunandprofit.com/posts/property-based-testing/)