AI

Tech workers in China are being instructed by their bosses to train AI agents to replace them—and it’s prompting a wave of soul-searching among otherwise enthusiastic early adopters.  Earlier this month a GitHub project called Colleague Skill, which claimed workers could use it to “distill” their colleagues’ skills and personality traits and replicate them with an AI agent, went viral on Chinese social media. Though the project was created as a spoof, it struck a nerve among tech workers, a number of whom told MIT Technology Review that their bosses are encouraging them to document their workflows in order to automate specific tasks and processes using AI agent tools like OpenClaw or Claude Code.  To set up Colleague Skill, a user names the coworker whose tasks they want to replicate and adds basic profile details. The tool then automatically imports chat history and files from Lark and DingTalk, both popular workplace apps in China, and generates reusable manuals describing that coworker’s duties—and even their unique quirks—for an AI agent to replicate.  Colleague Skill was created by Tianyi Zhou, who works as an engineer at the Shanghai Artificial Intelligence Laboratory. Earlier this week he told Chinese outlet Southern Metropolis Daily that the project was started as a stunt, prompted by AI-related layoffs and by the growing tendency of companies to ask employees to automate themselves. He didn’t respond to requests for further comment. Internet users have found humor in the idea behind the tool, joking about automating their coworkers before themselves. However, Colleague Skill’s virality has sparked a lot of debate about workers’ dignity and individuality in the age of AI. After seeing Colleague Skill on social media, Amber Li, 27, a tech worker in Shanghai, used it to recreate a former coworker as a personal experiment. Within minutes, the tool created a file detailing how that person did their job. “It is surprisingly good,” Li says. “It even captures the person’s little quirks, like how they react and their punctuation habits.” With this skill, Li can use an AI agent as a new “coworker” that helps debug her code and replies instantly. It felt uncanny and uncomfortable, Li says.  Even so,  replacing coworkers with agents could become a norm. Since OpenClaw became a national craze, bosses in China have been pushing tech workers to experiment with agents.  Although AI agents can take control of your computer, read and summarize news, reply to emails, and book restaurant reservations for you, tech workers on the ground say their utility has so far proven to be limited in business contexts. Asking employees to make manuals describing the minutiae of their day-to-day jobs the way Colleague Skill does is one way to help bridge that gap.  Hancheng Cao, an assistant professor at Emory University who studies AI and work, believes that companies have good reasons to push employees to create work blueprints like these, beyond simply following a trend. “Firms gain not only internal experience with the tools, but also richer data on employee know-how, workflows, and decision patterns. That helps companies see which parts of work can be standardized or codified into systems, and which still depend on human judgment,” he says. To employees, though, making agents or even blueprints for them can feel strange and alienating. One software engineer, who spoke with MIT Technology Review anonymously because of concerns about their job security, trained an AI (not Colleague Skill) on their workflow and found that the process felt reductive—as if their work had been flattened into modules in a way that made them easier to replace. On social media, workers have turned to bleak humor to express similar feelings. In one comment on Rednote, a user wrote that “a cold farewell can be turned into warm tokens,” quipping that if they use Colleague Skill to distill their coworkers into tasks first, they themselves might survive a little longer. The push for creating agents has also spurred clever countermeasures. Irritated by the idea of reducing a person to a skill, Koki Xu, 26 an AI product manager in Beijing, published an “anti-distillation” skill on GitHub on April 4. The tool, which took Xu about an hour to build, is designed to sabotage the process of creating workflows for agents. Users can choose between light, medium, and heavy sabotage modes depending on how closely their boss is observing the process, and the agent rewrites the material into generic, non-actionable language that would produce a less useful AI stand-in. A video Xu posted about the project went viral, drawing more than 5 million likes across platforms. Xu told MIT Technology Review that she has been following the Colleague Skill trend from the start and that it has made her think about alienation, disempowerment, and broader implications for labor. “I originally wanted to write an op-ed, but decided it would be more useful to make something that pushes back against it,” she says. Xu, who has undergraduate and master’s degrees in law, said the trend also raises legal questions. While a company may be able to argue that work chat histories and materials created on a work laptop are corporate property, a skill like this can also capture elements of personality, tone, and judgment, making ownership much less clear. She said she hopes Colleague Skill prompts more discussion about how to protect workers’ dignity and identity in the age of AI. “I believe it’s important to keep up with these trends so we (employees) can participate in shaping how they are used,” she says. Xu herself is an avid AI adopter, with seven OpenClaw agents set up across her personal and work devices. Li, the tech worker in Shanghai, says her company has not yet found a way to replace actual workers with AI tools, largely because they remain unreliable and require constant supervision. “I don’t feel like my job is immediately at risk,” she says. “But I do feel that my value is being cheapened, and I don’t know what to do about it.”

Cybersecurity has always had a dual-use problem: the same technical knowledge that helps defenders find vulnerabilities can also help attackers exploit them. For AI systems, that tension is sharper than ever. Restrictions intended to prevent harm have historically created friction for good-faith security work, and it can be genuinely difficult to tell whether any particular cyber action is intended for defensive usage or to cause harm. OpenAI is now proposing a concrete structural solution to that problem: verified identity, tiered access, and a purpose-built model for defenders. OpenAI team announced that it is scaling up its Trusted Access for Cyber (TAC) program to thousands of verified individual defenders and hundreds of teams responsible for defending critical software. The main focus of this expansion is the introduction of GPT-5.4-Cyber, a variant of GPT-5.4 fine-tuned specifically for defensive cybersecurity use cases. What Is GPT-5.4-Cyber and How Does It Differ From Standard Models? If you’re an AI engineer or data scientist who has worked with large language models on security tasks, you’re likely familiar with the frustrating experience of a model refusing to analyze a piece of malware or explain how a buffer overflow works — even in a clearly research-oriented context. GPT-5.4-Cyber is designed to eliminate that friction for verified users. Unlike standard GPT-5.4, which applies blanket refusals to many dual-use security queries, GPT-5.4-Cyber is described by OpenAI as ‘cyber-permissive’ — meaning it has a deliberately lower refusal threshold for prompts that serve a legitimate defensive purpose. That includes binary reverse engineering, enabling security professionals to analyze compiled software for malware potential, vulnerabilities, and security robustness without access to the source code. Binary reverse engineering without source code is a significant capability unlock. In practice, defenders routinely need to analyze closed-source binaries — firmware on embedded devices, third-party libraries, or suspected malware samples — without having access to the original code. That model was described as a GPT-5.4 variant purposely fine-tuned for additional cyber capabilities, with fewer capability restrictions and support for advanced defensive workflows including binary reverse engineering without source code. There are also hard limits. Users with trusted access must still abide by OpenAI’s Usage Policies and Terms of Use. The approach is designed to reduce friction for defenders while preventing prohibited behavior, including data exfiltration, malware creation or deployment, and destructive or unauthorized testing. This distinction matters: TAC lowers the refusal boundary for legitimate work, but does not suspend policy for any user. There are also deployment constraints. Use in zero-data-retention environments is limited, given that OpenAI has less visibility into the user, environment, and intent in those configurations — a tradeoff the company frames as a necessary control surface in a tiered-access model. For dev teams accustomed to running API calls in Zero-Data-Retention mode, this is an important implementation constraint to plan around before building pipelines on top of GPT-5.4-Cyber. The Tiered Access Framework: How TAC Actually Works TAC is not a checkbox feature — it is an identity-and-trust-based access framework with multiple tiers. Understanding the structure matters if you or your organization plans to integrate these capabilities. The access process runs through two paths. Individual users can verify their identity at chatgpt.com/cyber. Enterprises can request trusted access for their team through an OpenAI representative. Customers approved through either path gain access to model versions with reduced friction around safeguards that might otherwise trigger on dual-use cyber activity. Approved uses include security education, defensive programming, and responsible vulnerability research. TAC customers who want to go further and authenticate as cyber defenders can express interest in additional access tiers, including GPT-5.4-Cyber. Deployment of the more permissive model is starting with a limited, iterative rollout to vetted security vendors, organizations, and researchers. That means OpenAI is now drawing at least three practical lines instead of one: there is baseline access to general models; there is trusted access to existing models with less accidental friction for legitimate security work; and there is a higher tier of more permissive, more specialized access for vetted defenders who can justify it. The framework is grounded in three explicit principles. The first is democratized access: using objective criteria and methods, including strong KYC and identity verification, to determine who can access more advanced capabilities, with the goal of making those capabilities available to legitimate actors of all sizes, including those protecting critical infrastructure and public services. The second is iterative deployment — OpenAI updates models and safety systems as it learns more about the benefits and risks of specific versions, including improving resilience to jailbreaks and adversarial attacks. The third is ecosystem resilience, which includes targeted grants, contributions to open-source security initiatives, and tools like Codex Security. How the Safety Stack Is Built: From GPT-5.2 to GPT-5.4-Cyber It’s worth understanding how OpenAI has structured its safety architecture across model versions — because TAC is built on top of that architecture, not instead of it. OpenAI began cyber-specific safety training with GPT-5.2, then expanded it with additional safeguards through GPT-5.3-Codex and GPT-5.4. A critical milestone in that progression: GPT-5.3-Codex is the first model OpenAI is treating as High cybersecurity capability under its Preparedness Framework, which requires additional safeguards. These safeguards include training the model to refuse clearly malicious requests like stealing credentials. The Preparedness Framework is OpenAI’s internal evaluation rubric for classifying how dangerous a given capability level could be. Reaching ‘High’ under that framework is what triggered the full cybersecurity safety stack being deployed — not just model-level training, but an additional automated monitoring layer. In addition to safety training, automated classifier-based monitors detect signals of suspicious cyber activity and route high-risk traffic to a less cyber-capable model, GPT-5.2. In other words, if a request looks suspicious enough to exceed a threshold, the platform doesn’t just refuse — it silently reroutes the traffic to a safer fallback model. This is a key architectural detail: safety is enforced not only inside model weights, but also at the infrastructure routing layer. GPT-5.4-Cyber extends this stack further upward — more permissive for verified defenders, but wrapped in

In this tutorial, we implement how to run the Bonsai 1-bit large language model efficiently using GPU acceleration and PrismML’s optimized GGUF deployment stack. We set up the environment, install the required dependencies, and download the prebuilt llama.cpp binaries, and load the Bonsai-1.7B model for fast inference on CUDA. As we progress, we examine how 1-bit quantization works under the hood, why the Q1_0_g128 format is so memory-efficient, and how this makes Bonsai practical for lightweight yet capable language model deployment. We also test core inference, benchmarking, multi-turn chat, structured JSON generation, code generation, OpenAI-compatible server mode, and a small retrieval-augmented generation workflow, giving us a complete, hands-on view of how Bonsai operates in real-world use. Copy CodeCopiedUse a different Browser import os, sys, subprocess, time, json, urllib.request, tarfile, textwrap try: import google.colab IN_COLAB = True except ImportError: IN_COLAB = False def section(title): bar = “═” * 60 print(f”n{bar}n {title}n{bar}”) section(“1 · Environment & GPU Check”) def run(cmd, capture=False, check=True, **kw): return subprocess.run( cmd, shell=True, capture_output=capture, text=True, check=check, **kw ) gpu_info = run(“nvidia-smi –query-gpu=name,memory.total,driver_version –format=csv,noheader”, capture=True, check=False) if gpu_info.returncode == 0: print(” GPU detected:”, gpu_info.stdout.strip()) else: print(” No GPU found — inference will run on CPU (much slower).”) cuda_check = run(“nvcc –version”, capture=True, check=False) if cuda_check.returncode == 0: for line in cuda_check.stdout.splitlines(): if “release” in line: print(” CUDA:”, line.strip()) break print(f” Python {sys.version.split()[0]} | Platform: Linux (Colab)”) section(“2 · Installing Python Dependencies”) run(“pip install -q huggingface_hub requests tqdm openai”) print(” huggingface_hub, requests, tqdm, openai installed”) from huggingface_hub import hf_hub_download We begin by importing the core Python modules that we need for system operations, downloads, timing, and JSON handling. We check whether we are running inside Google Colab, define a reusable section printer, and create a helper function to run shell commands cleanly from Python. We then verify the GPU and CUDA environment, print the Python runtime details, install the required Python dependencies, and prepare the Hugging Face download utility for the next stages. Copy CodeCopiedUse a different Browser section(“3 · Downloading PrismML llama.cpp Prebuilt Binaries”) RELEASE_TAG = “prism-b8194-1179bfc” BASE_URL = f”https://github.com/PrismML-Eng/llama.cpp/releases/download/{RELEASE_TAG}” BIN_DIR = “/content/bonsai_bin” os.makedirs(BIN_DIR, exist_ok=True) def detect_cuda_build(): r = run(“nvcc –version”, capture=True, check=False) for line in r.stdout.splitlines(): if “release” in line: try: ver = float(line.split(“release”)[-1].strip().split(“,”)[0].strip()) if ver >= 13.0: return “13.1” if ver >= 12.6: return “12.8” return “12.4” except ValueError: pass return “12.4” cuda_build = detect_cuda_build() print(f” Detected CUDA build slot: {cuda_build}”) TAR_NAME = f”llama-{RELEASE_TAG}-bin-linux-cuda-{cuda_build}-x64.tar.gz” TAR_URL = f”{BASE_URL}/{TAR_NAME}” tar_path = f”/tmp/{TAR_NAME}” if not os.path.exists(f”{BIN_DIR}/llama-cli”): print(f” Downloading: {TAR_URL}”) urllib.request.urlretrieve(TAR_URL, tar_path) print(” Extracting …”) with tarfile.open(tar_path, “r:gz”) as t: t.extractall(BIN_DIR) for fname in os.listdir(BIN_DIR): fp = os.path.join(BIN_DIR, fname) if os.path.isfile(fp): os.chmod(fp, 0o755) print(f” Binaries extracted to {BIN_DIR}”) bins = sorted(f for f in os.listdir(BIN_DIR) if os.path.isfile(os.path.join(BIN_DIR, f))) print(” Available:”, “, “.join(bins)) else: print(f” Binaries already present at {BIN_DIR}”) LLAMA_CLI = f”{BIN_DIR}/llama-cli” LLAMA_SERVER = f”{BIN_DIR}/llama-server” test = run(f”{LLAMA_CLI} –version”, capture=True, check=False) if test.returncode == 0: print(f” llama-cli version: {test.stdout.strip()[:80]}”) else: print(f” llama-cli test failed: {test.stderr.strip()[:200]}”) section(“4 · Downloading Bonsai-1.7B GGUF Model”) MODEL_REPO = “prism-ml/Bonsai-1.7B-gguf” MODEL_DIR = “/content/bonsai_models” GGUF_FILENAME = “Bonsai-1.7B.gguf” os.makedirs(MODEL_DIR, exist_ok=True) MODEL_PATH = os.path.join(MODEL_DIR, GGUF_FILENAME) if not os.path.exists(MODEL_PATH): print(f” Downloading {GGUF_FILENAME} (~248 MB) from HuggingFace …”) MODEL_PATH = hf_hub_download( repo_id=MODEL_REPO, filename=GGUF_FILENAME, local_dir=MODEL_DIR, ) print(f” Model saved to: {MODEL_PATH}”) else: print(f” Model already cached: {MODEL_PATH}”) size_mb = os.path.getsize(MODEL_PATH) / 1e6 print(f” File size on disk: {size_mb:.1f} MB”) section(“5 · Core Inference Helpers”) DEFAULT_GEN_ARGS = dict( temp=0.5, top_p=0.85, top_k=20, repeat_penalty=1.0, n_predict=256, n_gpu_layers=99, ctx_size=4096, ) def build_llama_cmd(prompt, system_prompt=”You are a helpful assistant.”, **overrides): args = {**DEFAULT_GEN_ARGS, **overrides} formatted = ( f”<|im_start|>systemn{system_prompt}<|im_end|>n” f”<|im_start|>usern{prompt}<|im_end|>n” f”<|im_start|>assistantn” ) safe_prompt = formatted.replace(‘”‘, ‘\”‘) return ( f'{LLAMA_CLI} -m “{MODEL_PATH}”‘ f’ -p “{safe_prompt}”‘ f’ -n {args[“n_predict”]}’ f’ –temp {args[“temp”]}’ f’ –top-p {args[“top_p”]}’ f’ –top-k {args[“top_k”]}’ f’ –repeat-penalty {args[“repeat_penalty”]}’ f’ -ngl {args[“n_gpu_layers”]}’ f’ -c {args[“ctx_size”]}’ f’ –no-display-prompt’ f’ -e’ ) def infer(prompt, system_prompt=”You are a helpful assistant.”, verbose=True, **overrides): cmd = build_llama_cmd(prompt, system_prompt, **overrides) t0 = time.time() result = run(cmd, capture=True, check=False) elapsed = time.time() – t0 output = result.stdout.strip() if verbose: print(f”n{‘─’*50}”) print(f”Prompt : {prompt[:100]}{‘…’ if len(prompt) > 100 else ”}”) print(f”{‘─’*50}”) print(output) print(f”{‘─’*50}”) print(f” {elapsed:.2f}s | ~{len(output.split())} words”) return output, elapsed print(” Inference helpers ready.”) section(“6 · Basic Inference — Hello, Bonsai!”) infer(“What makes 1-bit language models special compared to standard models?”) We download and prepare the PrismML prebuilt llama.cpp CUDA binaries that power local inference for the Bonsai model. We detect the available CUDA version, choose the matching binary build, extract the downloaded archive, make the files executable, and verify that the llama-cli binary works correctly. After that, we download the Bonsai-1.7B GGUF model from Hugging Face, set up the model path, define the default generation settings, and build the core helper functions that format prompts and run inference. Copy CodeCopiedUse a different Browser section(“7 · Q1_0_g128 Quantization — What’s Happening Under the Hood”) print(textwrap.dedent(“”” ╔══════════════════════════════════════════════════════════════╗ ║ Bonsai Q1_0_g128 Weight Representation ║ ╠══════════════════════════════════════════════════════════════╣ ║ Each weight = 1 bit: 0 → −scale ║ ║ 1 → +scale ║ ║ Every 128 weights share one FP16 scale factor. ║ ║ ║ ║ Effective bits per weight: ║ ║ 1 bit (sign) + 16/128 bits (shared scale) = 1.125 bpw ║ ║ ║ ║ Memory comparison for Bonsai-1.7B: ║ ║ FP16: 3.44 GB (1.0× baseline) ║ ║ Q1_0_g128: 0.24 GB (14.2× smaller!) ║ ║ MLX 1-bit g128: 0.27 GB (12.8× smaller) ║ ╚══════════════════════════════════════════════════════════════╝ “””)) print(” Python demo of Q1_0_g128 quantization logic:n”) import random random.seed(42) GROUP_SIZE = 128 weights_fp16 = [random.gauss(0, 0.1) for _ in range(GROUP_SIZE)] scale = max(abs(w) for w in weights_fp16) quantized = [1 if w >= 0 else 0 for w in weights_fp16] dequantized = [scale if b == 1 else -scale for b in quantized] mse = sum((a – b) ** 2 for a, b in zip(weights_fp16, dequantized)) / GROUP_SIZE print(f” FP16 weights (first 8): {[f'{w:.4f}’ for w in weights_fp16[:8]]}”) print(f” 1-bit repr (first 8): {quantized[:8]}”) print(f” Shared scale: {scale:.4f}”) print(f” Dequantized (first 8): {[f'{w:.4f}’ for w in dequantized[:8]]}”) print(f” MSE of reconstruction: {mse:.6f}”) memory_fp16 = GROUP_SIZE * 2 memory_1bit = GROUP_SIZE / 8 + 2 print(f”n Memory: FP16={memory_fp16}B vs Q1_0_g128={memory_1bit:.1f}B ” f”({memory_fp16/memory_1bit:.1f}× reduction)”) section(“8 ·

In this tutorial, we explore property-based testing using Hypothesis and build a rigorous testing pipeline that goes far beyond traditional unit testing. We implement invariants, differential testing, metamorphic testing, targeted exploration, and stateful testing to validate both functional correctness and behavioral guarantees of our systems. Instead of manually crafting edge cases, we let Hypothesis generate structured inputs, shrink failures to minimal counterexamples, and systematically uncover hidden bugs. Also, we demonstrate how modern testing practices can be integrated directly into experimental and research-driven workflows. Copy CodeCopiedUse a different Browser import sys, textwrap, subprocess, os, re, math !{sys.executable} -m pip -q install hypothesis pytest test_code = r”’ import re, math import pytest from hypothesis import ( given, assume, example, settings, note, target, HealthCheck, Phase ) from hypothesis import strategies as st from hypothesis.stateful import RuleBasedStateMachine, rule, invariant, initialize, precondition def clamp(x: int, lo: int, hi: int) -> int: if x < lo: return lo if x > hi: return hi return x def normalize_whitespace(s: str) -> str: return ” “.join(s.split()) def is_sorted_non_decreasing(xs): return all(xs[i] <= xs[i+1] for i in range(len(xs)-1)) def merge_sorted(a, b): i = j = 0 out = [] while i < len(a) and j < len(b): if a[i] <= b[j]: out.append(a[i]); i += 1 else: out.append(b[j]); j += 1 out.extend(a[i:]) out.extend(b[j:]) return out def merge_sorted_reference(a, b): return sorted(list(a) + list(b)) We set up the environment by installing Hypothesis and pytest and importing all required modules. We begin constructing the full test suite by defining core utility functions such as clamp, normalize_whitespace, and merge_sorted. We establish the functional foundation that our property-based tests will rigorously validate in later snippets. Copy CodeCopiedUse a different Browser def safe_parse_int(s: str): t = s.strip() if re.fullmatch(r”[+-]?d+”, t) is None: return (False, “not_an_int”) if len(t.lstrip(“+-“)) > 2000: return (False, “too_big”) try: return (True, int(t)) except Exception: return (False, “parse_error”) def safe_parse_int_alt(s: str): t = s.strip() if not t: return (False, “not_an_int”) sign = 1 if t[0] == “+”: t = t[1:] elif t[0] == “-“: sign = -1 t = t[1:] if not t or any(ch < “0” or ch > “9” for ch in t): return (False, “not_an_int”) if len(t) > 2000: return (False, “too_big”) val = 0 for ch in t: val = val * 10 + (ord(ch) – 48) return (True, sign * val) bounds = st.tuples(st.integers(-10_000, 10_000), st.integers(-10_000, 10_000)).map( lambda t: (t[0], t[1]) if t[0] <= t[1] else (t[1], t[0]) ) @st.composite def int_like_strings(draw): sign = draw(st.sampled_from([“”, “+”, “-“])) digits = draw(st.text(alphabet=st.characters(min_codepoint=48, max_codepoint=57), min_size=1, max_size=300)) left_ws = draw(st.text(alphabet=[” “, “t”, “n”], min_size=0, max_size=5)) right_ws = draw(st.text(alphabet=[” “, “t”, “n”], min_size=0, max_size=5)) return f”{left_ws}{sign}{digits}{right_ws}” sorted_lists = st.lists(st.integers(-10_000, 10_000), min_size=0, max_size=200).map(sorted) We implement parsing logic and define structured strategies that generate constrained, meaningful test inputs. We create composite strategies such as int_like_strings to precisely control the input space for property validation. We prepare sorted list generators and bounds strategies that enable differential and invariant-based testing. Copy CodeCopiedUse a different Browser @settings(max_examples=300, suppress_health_check=[HealthCheck.too_slow]) @given(x=st.integers(-50_000, 50_000), b=bounds) def test_clamp_within_bounds(x, b): lo, hi = b y = clamp(x, lo, hi) assert lo <= y <= hi @settings(max_examples=300, suppress_health_check=[HealthCheck.too_slow]) @given(x=st.integers(-50_000, 50_000), b=bounds) def test_clamp_idempotent(x, b): lo, hi = b y = clamp(x, lo, hi) assert clamp(y, lo, hi) == y @settings(max_examples=250) @given(s=st.text()) @example(” attb n c “) def test_normalize_whitespace_is_idempotent(s): t = normalize_whitespace(s) assert normalize_whitespace(t) == t assert normalize_whitespace(” nt ” + s + ” t”) == normalize_whitespace(s) @settings(max_examples=250, suppress_health_check=[HealthCheck.too_slow]) @given(a=sorted_lists, b=sorted_lists) def test_merge_sorted_matches_reference(a, b): out = merge_sorted(a, b) ref = merge_sorted_reference(a, b) assert out == ref assert is_sorted_non_decreasing(out) We define core property tests that validate correctness and idempotence across multiple functions. We use Hypothesis decorators to automatically explore edge cases and verify behavioral guarantees such as boundary constraints and deterministic normalization. We also implement differential testing to ensure our merge implementation matches a trusted reference. Copy CodeCopiedUse a different Browser @settings(max_examples=250, deadline=200, suppress_health_check=[HealthCheck.too_slow]) @given(s=int_like_strings()) def test_two_parsers_agree_on_int_like_strings(s): ok1, v1 = safe_parse_int(s) ok2, v2 = safe_parse_int_alt(s) assert ok1 and ok2 assert v1 == v2 @settings(max_examples=250) @given(s=st.text(min_size=0, max_size=200)) def test_safe_parse_int_rejects_non_ints(s): t = s.strip() m = re.fullmatch(r”[+-]?d+”, t) ok, val = safe_parse_int(s) if m is None: assert ok is False else: if len(t.lstrip(“+-“)) > 2000: assert ok is False and val == “too_big” else: assert ok is True and isinstance(val, int) def variance(xs): if len(xs) < 2: return 0.0 mu = sum(xs) / len(xs) return sum((x – mu) ** 2 for x in xs) / (len(xs) – 1) @settings(max_examples=250, phases=[Phase.generate, Phase.shrink]) @given(xs=st.lists(st.integers(-1000, 1000), min_size=0, max_size=80)) def test_statistics_sanity(xs): target(variance(xs)) if len(xs) == 0: assert variance(xs) == 0.0 elif len(xs) == 1: assert variance(xs) == 0.0 else: v = variance(xs) assert v >= 0.0 k = 7 assert math.isclose(variance([x + k for x in xs]), v, rel_tol=1e-12, abs_tol=1e-12) We extend our validation to parsing robustness and statistical correctness using targeted exploration. We verify that two independent integer parsers agree on structured inputs and enforce rejection rules on invalid strings. We further implement metamorphic testing by validating invariants of variance under transformation. Copy CodeCopiedUse a different Browser class Bank: def __init__(self): self.balance = 0 self.ledger = [] def deposit(self, amt: int): if amt <= 0: raise ValueError(“deposit must be positive”) self.balance += amt self.ledger.append((“dep”, amt)) def withdraw(self, amt: int): if amt <= 0: raise ValueError(“withdraw must be positive”) if amt > self.balance: raise ValueError(“insufficient funds”) self.balance -= amt self.ledger.append((“wd”, amt)) def replay_balance(self): bal = 0 for typ, amt in self.ledger: bal += amt if typ == “dep” else -amt return bal class BankMachine(RuleBasedStateMachine): def __init__(self): super().__init__() self.bank = Bank() @initialize() def init(self): assert self.bank.balance == 0 assert self.bank.replay_balance() == 0 @rule(amt=st.integers(min_value=1, max_value=10_000)) def deposit(self, amt): self.bank.deposit(amt) @precondition(lambda self: self.bank.balance > 0) @rule(amt=st.integers(min_value=1, max_value=10_000)) def withdraw(self, amt): assume(amt <= self.bank.balance) self.bank.withdraw(amt) @invariant() def balance_never_negative(self): assert self.bank.balance >= 0 @invariant() def ledger_replay_matches_balance(self): assert self.bank.replay_balance() == self.bank.balance TestBankMachine = BankMachine.TestCase ”’ path = “/tmp/test_hypothesis_advanced.py” with open(path, “w”, encoding=”utf-8″) as f: f.write(test_code) print(“Hypothesis version:”, __import__(“hypothesis”).__version__) print(“nRunning pytest on:”, path, “n”) res = subprocess.run([sys.executable, “-m”, “pytest”, “-q”, path], capture_output=True, text=True) print(res.stdout) if res.returncode != 0: print(res.stderr) if res.returncode == 0: print(“nAll Hypothesis tests passed.”) elif res.returncode == 5: