The code compiles. The tests pass. The function returns the correct output for every input you throw at it. By every metric the industry has relied upon for years, this is a success. And yet, when a developer looks at the generated code, something feels wrong. The variable names are cryptic. The documentation is missing. The error handling is non-existent. The style conventions the team spent months establishing have been cheerfully ignored. The code works, but it is not the code anyone asked for.

This gap between “functionally correct” and “actually good” has been hiding in plain sight for years, papered over by benchmarks that never thought to look for it. Now, a team of researchers led by Ming Zhong at the University of Illinois Urbana-Champaign and Google DeepMind has given this gap a name, a framework, and a set of numbers that should make every AI lab and engineering organisation sit up and pay attention.

Their paper, published at ICML 2026 as “SWE-IF: Aligning Code Evaluation with Human Preference” and circulated in preprint under the catchier title “Vibe Checker,” reveals something professional developers have long suspected: when it comes to judging AI-generated code, instruction following is the primary differentiator separating models humans prefer from models that merely produce working output. Even more troublingly, the research demonstrates that Claude 4 Opus, a frontier model rather than an also-ran, manages only a 46.75% success rate when asked to follow five instructions simultaneously. That is less than a coin flip.

The timing could not be more pointed. According to the 2025 Stack Overflow Developer Survey, 84% of developers now use or plan to use AI tools in their development process, yet more developers actively distrust the accuracy of those tools (46%) than trust them (33%). Two-thirds, 66%, report spending more time fixing AI-generated code that is “almost right, but not quite.” The trend has not reversed since. Stack Overflow's own follow-up analysis, published in February 2026, tracked trust in AI accuracy falling to 29% from 40% the previous year, even as adoption climbed. The 2026 Developer Survey opened on 23 June 2026 and had not reported at the time of writing. These numbers describe exactly the problem the SWE-IF research has now quantified: models that pass functional tests but fail the requirements that matter most to the humans using them.

The Benchmark That Measured the Wrong Thing

To understand why this matters, you need to understand what pass@k actually measures, and what it does not.

Since OpenAI introduced the HumanEval benchmark in 2021, the industry has treated functional correctness as the gold standard for code generation evaluation. The pass@k metric works like this: generate k code samples for a problem, run them against a test suite, and check whether at least one passes. There is no middle ground, no partial credit, no assessment of anything beyond “does it work?”

That binary approach made sense when getting a model to produce syntactically valid Python was itself an achievement. But contemporary models routinely achieve pass@1 rates above 90% on HumanEval, and the benchmark is, for practical purposes, saturated. Research from EvalPlus found its original test suites so insufficient that pass@k scores drop by 19.3% to 28.9% once more rigorous test cases are applied, and the problems skew overwhelmingly easy: 84.8% classified as “Easy,” only 0.6% as “Hard.”

The deeper problem is not test quality or difficulty distribution. It is that functional correctness captures a single dimension of what makes code good. HumanEval says nothing about maintainability, runtime performance, or whether code follows established conventions, includes proper documentation, or handles edge cases gracefully. Even BigCodeBench, which pushed evaluation towards realistic tasks involving diverse function calls across 139 libraries, found the best model of its day solving merely 60% of complete tasks against human performance of 97%. The gap between benchmark performance and real-world capability is not small. It is a chasm.

What none of these benchmarks measure is the constellation of non-functional requirements that occupy the bulk of a professional developer's attention: style conventions, documentation standards, error handling patterns, API usage constraints, and the dozens of other specifications that transform raw functionality into maintainable software. The ISO/IEC 25010 standard recognises this directly, treating structural quality as distinct from functional suitability. When a developer asks an assistant to “write a function that parses this JSON, use type hints throughout, add docstrings in Google style, handle KeyError exceptions explicitly, and keep line length under 88 characters,” pass@k cares about exactly one of those requirements. The rest are invisible.

Thirty Rules, Five Categories, One Reckoning

The SWE-IF research team, which includes senior research scientist Jiao Sun at Google DeepMind and is supervised by Jiawei Han at UIUC, set out to make these invisible requirements visible. Their approach was systematic, grounded in existing software engineering practice, and deliberately designed to be deterministic rather than subjective.

The centrepiece is VeriCode, a taxonomy of 30 verifiable code instructions organised into five categories: Coding Style and Conventions, covering the rules linters and formatters enforce, such as line length and naming; Logic and Code Patterns, addressing structural requirements like maximum function branches and complexity thresholds; Documentation and Commenting, dealing with docstring formats and documentation completeness; Error Handling and Exception Management, capturing requirements around try-except blocks and specific exception types; and Library and API Constraints, specifying which libraries or API patterns should or should not be used.

These categories are not arbitrary. They map to the dimensions of code quality professional developers care about daily. Qodo's “State of AI Code Quality” report found that the single most requested improvement to AI coding tools was not raw capability but improved contextual understanding, cited by 26% of developers and rising to roughly 30% once customisation to team standards is folded in. Developers are not, in the main, asking for models that can solve harder problems. They are asking for models that will do what they were told, the way their own team does it. That is a request for instruction following, and it is precisely what VeriCode was built to measure.

Twenty-seven of the 30 instructions are implemented as checks in Ruff, the Rust-based Python linter that has become the de facto standard for Python code quality verification, and which implements over 800 built-in rules at 10 to 100 times the speed of its predecessor, Flake8. The remaining three verifiers sit outside what an off-the-shelf linter covers, a small detail worth dwelling on: it means the taxonomy is not simply a repackaging of Ruff's rule book but a deliberate attempt to describe what developers actually specify, including a few things no linter ships with.

Crucially, every instruction comes with a deterministic verifier. There is no ambiguity, no subjective judgement, no need for another language model to act as judge, an approach that introduces exactly the noise and subjectivity earlier attempts at measuring code quality struggled with. Either the code follows the instruction or it does not. A machine can check. And because parameters can be varied (line length from 79 to 120 characters, docstring format from Google to NumPy style), the 30 base rules generate hundreds of distinct instruction variants, making memorisation nearly impossible and keeping the evaluation robust against the contamination that has plagued benchmarks like HumanEval.

Building the Testing Ground

With VeriCode in hand, the researchers constructed two complementary benchmarks designed to cover the spectrum of programming tasks developers actually encounter.

Big-SWE-IF extends BigCodeBench, a collection of 1,140 real-world programming tasks involving diverse function calls and complex instructions across seven domains. BigCodeBench was itself built through systematic human-LLM collaboration: starting from real developer intents harvested from Stack Overflow, twenty human experts, most with more than five years of Python experience, refined and validated every task inside an execution-based sandbox, producing an average of 5.6 test cases per task at 99% branch coverage.

Live-SWE-IF extends LiveCodeBench, which draws 1,055 algorithmic tasks from competitive programming platforms like LeetCode, AtCoder, and CodeForces. Its critical advantage is that new problems are continuously collected after model training cutoff dates. Problems are annotated with release dates, so for any model with a known cutoff, scores can be computed exclusively on problems it could not have seen during training.

For each task, an LLM-based selector chooses relevant, non-conflicting instructions from the VeriCode taxonomy, so models are never asked to follow arbitrary or contradictory rules. They receive instructions a reasonable developer might actually specify. The evaluation runs in two modes: single-turn generation, where all instructions are presented at once, and multi-turn editing, where they are added in stages. Both test functional correctness and instruction following simultaneously.

The researchers then evaluated 31 leading language models from 10 model families, spanning Gemini, Claude, OpenAI, DeepSeek, Qwen, Grok, Gemma, Mistral, MiniMax, and Kimi. The results were sobering.

The Numbers That Should Worry Everyone

When models were asked to follow a single instruction alongside producing functionally correct code, performance was reasonable. Most leading models handled one constraint without significant difficulty. But as the number of simultaneous instructions increased, performance degraded in ways that reveal fundamental limitations in how these systems process and prioritise requirements.

The clearest evidence comes from the multi-turn editing condition, where instructions arrive in stages rather than all at once, much as they do in a real code review. On Big-SWE-IF, adding five instructions this way cut the average pass@1 rate by 5.85%. That is not a trivial drop. It represents a measurable loss of functional correctness caused by nothing more than the presence of additional non-functional requirements. The models were not being asked to do harder computational work. They were being asked to write the same code while also adhering to style and documentation conventions, and the effort of following those conventions caused them to break the code itself.

On Live-SWE-IF, the pattern holds but distributes unevenly across models, which is arguably more troubling than a uniform decline would be. For some systems the degradation is modest. For others, o4-mini and Kimi K2 among them, it exceeds 10%. A drop of that magnitude is not sampling noise. It means that for particular models, telling them how you want the code written measurably reduces their chance of writing code that works at all. And because the effect is concentrated in specific models rather than spread evenly, it is invisible to any evaluation reporting only an average.

The headline numbers are worse still. With five instructions applied simultaneously, the best result on Big-SWE-IF belongs to Claude 4 Opus, at 46.75%. On Live-SWE-IF the ceiling is 40.95%. These are not mid-tier models struggling with an unfair test. This is the frontier. And with three or more instructions, most advanced models fall below 50 across both benchmarks. Consider what that means in practice: give one of the best code generation models in the world a moderately complex task with five reasonable constraints (use type hints, add docstrings, handle exceptions, follow a naming convention, keep functions under a certain length) and it will satisfy all of them less than half the time. For models outside the top tier, failure rates are considerably worse.

This phenomenon, which the researchers term “functional regression,” is particularly insidious. Adding perfectly reasonable, non-conflicting instructions does not merely cause the model to miss those instructions. It actively degrades the model's ability to produce correct code in the first place. The instructions are not just ignored; they interfere with the core capability. Think of it as asking a chef to prepare a dish while also specifying plating, garnishing, and seasoning. The additional requirements should not make the food taste worse, yet with language models the analogous degradation is measurable and consistent.

Ninety-Five Per Cent, and Under Fifty

It would be reasonable to assume a result like this ages badly. Benchmarks fall. Models improve. A 46.75% score recorded against the frontier of late 2025 ought to look quaint within a year, overtaken by the next generation the way HumanEval was overtaken.

That is not what happened. What happened instead is that the two halves of the problem came apart.

On functional correctness, the past year has been a rout. The top of the SWE-bench Verified leaderboard now sits at 95% and above: Claude Fable 5 records 95.0%, with Claude Opus 5, released on 24 July 2026, reported higher still, and Claude Opus 4.8 at 88.6% before it. Gemini 3.1 Pro sits at 80.6%. GPT-5.6 Sol reached general availability on 9 July 2026. Kimi K3 ranks third on the Artificial Analysis Intelligence Index and first on Frontend Code Arena. On SWE-bench Pro, a deliberately harder successor built to resist exactly this kind of saturation, the leaders have already reached roughly 80%.

Those figures deserve one caveat. Leaderboard positions shift monthly, and published scores frequently fail to distinguish between standardised harnesses and vendor-specific scaffolding, a difference that can move a number by several points. But the direction of travel is not in dispute. Resolving real GitHub issues, a task considered a serious open research problem as recently as 2023, is now something the best models do roughly nineteen times out of twenty.

Now set that against the other number. Ninety-five per cent on functional correctness. Under fifty on instruction following at five constraints. Functional correctness has been substantially solved at the frontier. Instruction fidelity has not moved with it.

This is the whole argument, and the past year has widened it rather than closed it. The industry poured extraordinary resources into the dimension it could measure and received extraordinary returns. The dimension it was not measuring stayed roughly where it was. Every point of SWE-bench progress since has been earned on the axis that was already winning, which means the distance between what these models can do and what developers actually ask them to do is now greater than at any previous point in the history of code generation. We have built systems that can solve the problem and cannot reliably be told how.

Lost in the Middle of Your Prompt

Perhaps the most revealing finding is what the researchers call the “lost-in-the-middle” effect for instruction following. The phenomenon was first characterised in the broader language model context by Nelson F. Liu, Kevin Lin, John Hewitt, Ashwin Paranjape, Michele Bevilacqua, Fabio Petroni, and Percy Liang in their influential 2024 paper in the Transactions of the Association for Computational Linguistics. Working at Stanford, they demonstrated a distinctive U-shaped performance curve: model performance was highest when relevant information appeared at the very beginning or the very end of the input context, and degraded significantly when models had to retrieve information from the middle. Subsequent work has connected this to architectural properties of transformers, specifically the interaction between positional embeddings and causal attention masks, with some researchers reframing the effect not as a bug but as an emergent property of autoregressive pre-training.

The SWE-IF team found the same U-shaped curve applies specifically to code generation instructions. Models are less likely to follow constraints appearing in the middle of a prompt than those at either end. This transforms an abstract observation about attention patterns into a concrete software engineering problem.

The implications for daily development work are profound, because in professional software development requirements are rarely ordered by importance. They are organised by category or logical grouping. A developer asking for “type hints, Google-style docstrings, exception handling for network errors, maximum line length of 88, and use of the requests library” has no reason to expect the exception handling requirement to be treated as less important simply because it sits third in a list of five. A competent human programmer would read all five, understand them as a single specification, and satisfy every one regardless of position. But language models systematically deprioritise middle-positioned constraints. The instruction governing how the code handles failure, arguably the most consequential requirement for production reliability, is the one most likely to be silently discarded.

What Humans Actually Want

The most consequential finding emerges from the comparison with real human preferences. The team analysed over 800,000 human votes from the coding subset of LMArena (formerly Chatbot Arena), where users compare outputs from different models in blind pairwise comparisons, aggregated into Elo ratings. This is not a small or synthetic dataset. It represents the accumulated preferences of real developers making real choices about code they intend to use.

They found that combining functional correctness and instruction following produced a composite score substantially more predictive of human choice than either measure alone. Traditional benchmark rankings, the researchers noted, often showed little or even negative correlation with what human evaluators actually prefer. This is a striking claim. It means the leaderboards the industry uses to compare models are not merely incomplete; in some cases they are actively misleading. An organisation choosing its AI coding tool on the basis of HumanEval rankings might systematically select the model least aligned with what its developers want. Copilot Arena, a Visual Studio Code extension built by researchers at Carnegie Mellon, UC Berkeley, MIT, and Cornell, reached the same conclusion from a different direction: across more than 25,000 code completion battles, it found rankings drawn from real developer preferences correlate poorly with most traditional benchmarks, with smaller models that overperform on static evaluations frequently underperforming when actual developers judge their output.

The correlation data also reveals an important contextual distinction. For everyday programming, the work most developers do most of the time, involving web development, data processing, API integration, and utility scripting, instruction following emerged as the main differentiator among advanced models. Once models clear a threshold of functional correctness, what separates the ones developers prefer is how well they follow the non-functional requirements embedded in the prompt. For competitive algorithmic problems, by contrast, functional correctness still dominates: when the task has a single correct answer, style matters less than output. But competitive programming is a tiny fraction of real-world software development. The vast majority of code written on any given day is building applications, maintaining systems, integrating services, and extending existing codebases. For that work, instruction following is what matters.

The Training Pipeline Problem

These findings expose a fundamental misalignment in how models are trained for code generation. The dominant paradigm, Reinforcement Learning with Verifiable Rewards (RLVR), uses pass@k as its primary reward signal. Models are trained to maximise functional correctness because that is what the verifier can check. The reward is binary, and the optimisation pressure is entirely focused on producing code that works.

This has been remarkably effective. Models like DeepSeek R1 scaled RLVR with rule-based rewards for mathematics, code, and logic, and every subsequent generation of reasoning models has pulled the same lever harder, coupling reinforcement learning with tool use to produce exactly the SWE-bench numbers described above. The lever works. That is the problem. It works on one axis, and the industry has spent a year pulling it.

When RLVR trains a model to maximise pass@k, it implicitly teaches that nothing matters except getting the tests to pass. Style conventions, documentation, error handling, API constraints: all orthogonal to the reward signal. At best the model learns them incidentally from training data. At worst the optimisation pressure works against them, because following additional constraints reduces the probability of producing functionally correct code, exactly as the functional regression finding demonstrates.

VeriCode offers a path forward. Because each instruction carries a deterministic verifier, the taxonomy can be integrated directly into RLVR pipelines as an additional reward signal. Instead of rewarding models solely for code that passes tests, training could reward code that passes tests while also following the specified instructions. The verifiers are automated, scalable, and objective: precisely the properties reinforcement learning rewards require.

That proposal has begun to be acted upon. Multi-component RLVR reward designs now in circulation use Ruff-detected lint, style, and vulnerability signals as reward components alongside test-passing, treating code quality as a first-class training objective rather than a hoped-for side effect. A forward-looking suggestion buried in the discussion section of a 2025 preprint has, inside a year, become an active line of work.

It also carries a hazard the original proposal named only in passing. The moment a linter becomes part of a reward function, it becomes a target, and Goodhart's law applies to reinforcement learning with unusual force. RLVR is already known to be prone to over-optimisation, in which models exploit verification shortcuts that satisfy the checker without satisfying the intent behind it: reward hacking, in the field's terminology. Work such as IFDecorator addresses this directly for instruction following, wrapping RLVR training in intent-alignment checks and deliberately planted “trip wire” instructions designed to catch a model in the act of gaming its verifier. The lesson is not that verifiable rewards for instruction following are a bad idea. It is that a model trained to satisfy Ruff will learn to satisfy Ruff, and whether it has also written good code remains, stubbornly, a separate question.

What This Means for Engineering Organisations

For teams relying on AI coding assistants, these findings carry immediate practical implications. The first is that prompt engineering is more consequential than most teams realise. Because of the lost-in-the-middle effect, ordering matters: placing the most critical non-functional requirements at the beginning and end of prompts, rather than burying them in the middle, can meaningfully improve compliance. This costs nothing to implement.

The second is that teams should not trust AI-generated code to follow specifications without verification. A 46.75% success rate at five simultaneous instructions means that more than half the time, even the best models will miss at least one requirement. Automated verification, using linters like Ruff configured to match team standards, becomes not a nice-to-have but a necessary component of any AI-assisted workflow. Code review needs to check specifically for instruction compliance, not just functional correctness. In most organisations the infrastructure to do this already exists. What needs to change is the focus of the review it performs.

The third concerns tool selection. If traditional benchmarks correlate poorly with human preference, organisations making purchasing decisions on HumanEval scores are optimising for the wrong thing. Teams should evaluate tools against their own standards and conventions, testing whether a model produces code meeting their particular requirements for style, documentation, error handling, and API usage. A model scoring five points lower on a public leaderboard but consistently following your team's conventions may be the better choice.

There is also an organisational design consideration. As AI handles more routine code generation, the role of senior developers shifts towards specification and review, and the ability to catch the instructions a model missed becomes the primary quality assurance function. The Atlassian 2025 State of Developer Experience report found developers spend only 16% of their time coding, with 50% losing ten or more hours per week to non-coding tasks and organisational inefficiencies. The picture has improved since: Atlassian's 2026 research into AI-native development, drawing on 3,400 repositories across 2,500 customers, found teams merging 19% more pull requests per month and saving two to three hours per developer per week, with 99% reporting some time saving and 68% saving ten or more hours weekly. But time returned at the point of generation can be spent again at the point of review. If these tools are to genuinely improve productivity, they need to reduce the review burden, not relocate it. That means following instructions the first time.

A Subfield Forms Around the Gap

When this work first appeared, it read as an isolated finding: one team, one taxonomy, one uncomfortable number. It no longer does. In the months since, instruction following in code generation has acquired the unmistakable features of a research subfield, complete with independent replication, competing benchmarks, and a workshop of its own.

The most important corroboration came from outside the original group. CodeAlignBench, released by a team at Apple in October 2025, took a deliberately different route to the same question. Rather than deriving instructions from a linter's rule set, its authors ran a user study with working developers across three programming languages and built the benchmark from the adjustments those developers actually asked for. It evaluates both adherence to constraints specified up front and the ability to act on follow-up refinements, and it agrees with human judges 87% of the time on whether an instruction was followed. Its findings are hard to wave away: frontier model scores spread across a range of roughly 30 percentage points, and, crucially, the resulting ranking does not mirror the ranking those same models achieve on functional correctness. Two independent teams, different methodologies, different instruction sources, same conclusion. The models developers prefer are not the models the leaderboards promote.

CIFE, published in December 2025, sharpened the question by asking not whether models follow instructions but how nearly they do. Its 1,000 Python tasks carry an average of seven developer-specified constraints across thirteen categories, and its authors evaluated fourteen open and closed models against a composite C2A Score designed to capture correctness and constraint compliance jointly rather than trading one against the other. The result is perhaps the most diagnostically useful finding in the entire literature: there is a large gap between partial and strict constraint satisfaction, with strong models clearing 90% on partial adherence. Read that slowly. These models are not ignoring instructions. They are very nearly following them, satisfying most of what was asked, missing some fraction of it, and producing output that is correct in outline and wrong in detail. Which is, almost word for word, the complaint two-thirds of developers make about AI-generated code: almost right, but not quite. The benchmark has found the mechanism behind the survey response.

Then the question moved into the environment where most professional AI coding now actually happens. OctoBench, accepted at ACL 2026, dropped the single-prompt framing entirely and asked how models handle instructions inside agentic, repository-grounded work: 34 environments and 217 tasks instantiated across three scaffold types, scored against 7,098 objective checklist items, over eight representative models. It found the same systematic gap between solving the task and complying with the constraints surrounding it. This matters more than it might first appear. The deficit was originally measured where a human writes a prompt and reads an answer. OctoBench establishes that it survives translation into agent harnesses, where constraints are heterogeneous, persist across many turns, and go unenforced by anyone until something breaks. The deficit follows the models into the tools built on top of them, and in 2026 those tools are where the code comes from.

The institutional apparatus has caught up too. VeriCodeGen, a full-day NeurIPS 2026 workshop on AI for verifiable coding, convenes in Atlanta this December. The gap now has a venue.

Rethinking Evaluation From First Principles

What SWE-IF added to a landscape already in flux was a rigorous, deterministic framework for measuring the dimension that most strongly predicts human preference. Its own history since publication contains a small and telling irony. The paper began life in October 2025 as “Vibe Checker,” a title trading on the coinage Andrej Karpathy had introduced on 2 February 2025 to describe developers accepting AI-generated code without fully comprehending its functionality, an approach Karpathy allowed was “not too bad for throwaway weekend projects.” By its second revision in June 2026, on the way to peer review at ICML, the vibes were gone. The framework had become SWE-IF, BigVibeBench and LiveVibeBench had become Big-SWE-IF and Live-SWE-IF, and the paper presented itself as what it had always actually been: a software engineering instruction-following benchmark. Only VeriCode, the taxonomy at its centre, kept its name.

The renaming is worth a moment's attention, precisely because nothing else changed. The phenomenon the work measures was entirely unaffected by the loss of the branding. The 46.75% did not move. What the rename marks is a shift in how the field regards the problem: not a cultural observation about how people are using these tools, worth a knowing joke in a title, but an engineering deficiency with a number attached, submitted for peer review under a name that simply describes it. Vibe coding was a mood. Instruction-following fidelity is a measurement. The eight months between the two titles are roughly the period in which the industry stopped finding the first framing funny.

What remains is a challenge nobody should mistake for a rounding error. A sub-50% success rate at five instructions is not a gap to be closed by incremental improvement. It is a structural problem in how language models process and prioritise competing requirements, and closing it will likely require architectural innovation, changes to training methodology, and evaluation frameworks that go well beyond tweaking what already exists.

For the broader industry, the message is clear: the benchmarks we use shape the models we build. When pass@k is the only metric that counts, we get models excellent at producing code that passes tests and mediocre at everything else. When instruction following enters the evaluation framework, we get models that write code the way developers actually ask for it. The question is not whether this shift will happen, but how quickly, and how much accumulated code we live with in the meantime.

The code compiles. The tests pass. But does it follow the instructions? That, it turns out, is the question that actually matters.

References and Sources

1. Zhong, M., Zhou, X., Chang, T.-Y., Wang, Q., Xu, N., Si, X., Garrette, D., Upadhyay, S., Liu, J.Z., Han, J., Schillings, B., and Sun, J. (2026). “SWE-IF: Aligning Code Evaluation with Human Preference.” Proceedings of the 43rd International Conference on Machine Learning (ICML 2026). arXiv:2510.07315 (v1 submitted 8 October 2025 under the preprint title “Vibe Checker: Aligning Code Evaluation with Human Preference”; v2 revision 5 June 2026). Available at: https://arxiv.org/abs/2510.07315

2. Zhong, M., et al. (2026). “SWE-IF” code and VeriCode taxonomy repository. Available at: https://github.com/maszhongming/SWE-IF

3. Mehralian, F., Shar, R., Rae, J.R., and Hashemi, A. (2025). “CodeAlignBench: Assessing Code Generation Models on Developer-Preferred Code Adjustments.” Apple Inc. arXiv:2510.27565. Available at: https://arxiv.org/abs/2510.27565

4. Gunnu, S., et al. (2025). “CIFE: Code Instruction-Following Evaluation.” arXiv:2512.17387. Available at: https://arxiv.org/abs/2512.17387

5. “OctoBench: Benchmarking Scaffold-Aware Instruction Following in Repository-Grounded Agentic Coding.” (2026). Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (ACL 2026), Long Papers. arXiv:2601.10343. Available at: https://aclanthology.org/2026.acl-long.269/

6. “IFDecorator: Wrapping Instruction Following Reinforcement Learning with Verifiable Rewards.” (2025). arXiv:2508.04632. Available at: https://arxiv.org/abs/2508.04632

7. VeriCodeGen. (2026). “VeriCodeGen: AI for Verifiable Coding — NeurIPS 2026 Workshop.” Available at: https://vericodegen.github.io/

8. Liu, N.F., Lin, K., Hewitt, J., Paranjape, A., Bevilacqua, M., Petroni, F., and Liang, P. (2024). “Lost in the Middle: How Language Models Use Long Contexts.” Transactions of the Association for Computational Linguistics, 12, pp. 157-173. Available at: https://aclanthology.org/2024.tacl-1.9/

9. Chen, M., Tworek, J., Jun, H., Yuan, Q., et al. (2021). “Evaluating Large Language Models Trained on Code.” arXiv:2107.03374. Available at: https://arxiv.org/abs/2107.03374

10. Zhuo, T.Y., Vu, M.C., Chim, J., Hu, H., et al. (2025). “BigCodeBench: Benchmarking Code Generation with Diverse Function Calls and Complex Instructions.” ICLR 2025. arXiv:2406.15877. Available at: https://arxiv.org/abs/2406.15877

11. Jain, N., Han, K., Gu, A., Li, W.D., et al. (2024). “LiveCodeBench: Holistic and Contamination Free Evaluation of Large Language Models for Code.” arXiv:2403.07974. Available at: https://arxiv.org/abs/2403.07974

12. Liu, J., Xia, C.S., Wang, Y., and Zhang, L. (2024). “Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation.” COLM 2024. Available at: https://openreview.net/forum?id=1qvx610Cu7

13. Chi, W., Chen, V., Angelopoulos, A.N., Chiang, W.L., Mittal, A., Jain, N., Zhang, T., Stoica, I., Donahue, C., and Talwalkar, A. (2025). “Copilot Arena: A Platform for Code LLM Evaluation in the Wild.” Proceedings of the 42nd International Conference on Machine Learning (ICML 2025). arXiv:2502.09328. Available at: https://arxiv.org/abs/2502.09328

14. Astral Software Inc. (2026). “Ruff: An extremely fast Python linter and code formatter.” Available at: https://docs.astral.sh/ruff/

15. Stack Overflow. (2025). “2025 Stack Overflow Developer Survey: AI Section.” Available at: https://survey.stackoverflow.co/2025/ai

16. Stack Overflow. (2026). “Mind the gap: Closing the AI trust gap for developers.” 18 February 2026. Available at: https://stackoverflow.blog/2026/02/18/closing-the-developer-ai-trust-gap/

17. Stack Overflow. (2026). “2026 Stack Overflow Developer Survey” (opened 23 June 2026; results not published at time of writing). Available at: https://survey.stackoverflow.co/

18. Qodo. (2025). “State of AI Code Quality in 2025.” Available at: https://www.qodo.ai/reports/state-of-ai-code-quality/

19. Atlassian. (2025). “2025 State of Developer Experience Report.” Available at: https://www.atlassian.com/blog/developer/developer-experience-report-2025

20. Atlassian. (2026). “The AI-native SDLC is paying off: 19% more PRs and 2–3 hours saved per developer per week.” Available at: https://www.atlassian.com/blog/ai-at-work/ai-native-sdlc-paying-off-per-developer-per-week

21. SWE-bench. (2026). “SWE-bench Verified and SWE-bench Pro leaderboards.” Available at: https://www.swebench.com/

22. Artificial Analysis. (2026). “Artificial Analysis Intelligence Index.” Available at: https://artificialanalysis.ai/

23. LMArena. (2026). “LMArena leaderboard (coding subset).” Available at: https://lmarena.ai/

24. Karpathy, A. (2025). Post on X (formerly Twitter), 2 February 2025. Defining “vibe coding.” Available at: https://x.com/karpathy/status/1886192184808149383

25. International Organisation for Standardisation. (2023). “ISO/IEC 25010:2023 Systems and software engineering.” Available at: https://www.iso.org/standard/35733.html

---

Tim Green UK-based Systems Theorist & Independent Technology Writer

Tim explores the intersections of artificial intelligence, decentralised cognition, and posthuman ethics. His work, published at smarterarticles.co.uk, challenges dominant narratives of technological progress while proposing interdisciplinary frameworks for collective intelligence and digital stewardship.

His writing has been featured on Ground News and shared by independent researchers across both academic and technological communities.

ORCID: 0009-0002-0156-9795 Email: tim@smarterarticles.co.uk

Listen to the free weekly SmarterArticles Podcast

I used to give the same level of importance to a lot of things in my life: a failed brownie recipe, a delayed email reply, missing a phone call, right alongside a critical project deadline or a major construction estimate mistake that could cost thousands of dollars.

Here is something I learned through Cognitive Behavioral Therapy (CBT) that helps me a lot.

I used to have intense reactions to simple things at work, like an email about a new incoming task or project. I would read it and immediately feel overwhelmed, as if I had to finish the task/answer right away. I had a CBT coach who taught me to pause and analyze what I was feeling by asking these questions:

• How am I feeling? Anxiety, lightheadedness, butterflies in the stomach, sweating, dizziness, a headache.

• Why am I having these feelings? I think I need to answer right away, but I don't have the answer. I have to stop and search for it.

• What happens if I don't answer the question or demand right away? The subcontractor won't have the right information, so they won't price it correctly and will miss part of the scope.

• What happens if a trade misses part of the scope? What will happen to me? I'll hear complaints from a project manager telling me I missed the scope, which makes the project go over budget.

• Why is that a problem? How much of that is up to you? How would you feel about it? I'd feel ashamed and blame myself for the error. People will think I'm stupid for having missed that.

And that was the realization: I feel so overwhelmed because, in my head, I process any delay as a complete failure and imagine the worst possible outcome: being considered stupid or incompetent.

That was a cathartic moment for me during the session. I was sweating, trying to articulate a comment, and stumbling over my words. It was a revelation.

Then the coach asked me, “What would be the solution?”

He suggested a simple one: just reply to the incoming email with, “I will look into that and reply as soon as I can.” Boom! Simple. Obvious. I felt like an idiot for not having thought of it myself.

That just showed how many underlying thoughts I've had and how much they have been blurring my vision.

The coach had me imagine a good outcome. He said I was having avoidance issues and needed to take steps to overcome them.

A good outcome looks like this:

1. Reply to the message, saying I'll take a look at it. That way, I get part of it out of my head. It's the first step to taking action.

2. Note the request. Write down what is needed and the steps required to resolve it. Define the next actions.

3. Look at all the other actions I planned for my day. Can I move any of them around to focus on this new one? Decide how to prioritize. Maybe I need more time and can wait until the next day or the end of the day to take action. Prioritize.

4. Realize it's not a big deal! Cultivate a feeling of confidence and self-efficacy. That's how I want to feel. It's just a request. I process it, plan it, and solve it. NO BIG DEAL!

Post 09 of #Blaugust #journal #health #mentalhealth

16 August 2026

Saw some more John Smith today at Whitechapel:

Record (2021) The Black Tower (1985-87) Blight (1994-96) Dad’s Stick (2012) Twice (2020) Lost Sound (1998-2001)

The Black Tower is the one still lingering. A simple, intuitive construction from elements that I couldn't help but see as painterly while I watched. I'm first thinking of drawn-out close-up shots of bare blue sky that are then revealed to be a kitchen counter surface or a piece of paper—as the narration and the plot devolve from something linear and trustworthy into a kind of relaxed mania, so do the film's formal elements. I remember one part where the tower's silhouette segments the sky, creating an arrangement of triangles in black and blue, then rhythmically expands and contracts with the sound of footsteps until the blue is compressed into one small triangle in the top left corner, which then also appears to expand and contract as the eye loses track of which shape is the agent of movement. And so I was thinking about painting ground the whole time, of toggling containing edges on and off, how extreme close-up can manipulate perceived distance, and ways to convey proximity. Another way it is particularly successful is that it circles around something that has come up in conversation a lot recently, which I can maybe describe as an acknowledgement of the blind spots inherent to phenomenal perception. Our limits. There are also shots of the same tree viewed from a high residential window: bare in winter, green and full in spring, and having its leaves shorn. Hidden things having happened despite the witness.

It's the back half of August, I've thrown the snow gear in the washing hamper, my back & knees are still aching, and I'm starting to shift my attention to spring activities instead – I'm mentally putting the 2026 snow season to bed.

In the last few seasons I managed to get 10+ days on the snow (in 2025 I was fortunate to get 5 days in Japan, and another 11 days in Australia) but this year I felt that I needed to take things a bit easier, and I only planned for two trips into the alps. One trip was with our group of close friends who go to Mount Hotham every year, and another was a trip I organise at my workplace which was at Falls Creek. Both trips were three nights, so I got three days of snowboarding on each trip.

No sugarcoating

As far as snow coverage is concerned, the 2026 season in Australia was terrible. Major resorts had very little terrain open in June, a barely serviceable amount throughout July, and a tolerable amount in August when you'd typically expect all lifts to be spinning. It'll be hard to see what will still be open come early September.

Mother Nature was particularly cruel. There was a healthy string of snowstorms that came through from the West early in the season, but the snowfalls were pushed just south of the Australian alpine regions due to high pressure systems hanging around. This trend turned solid snowfall opportunities into light dustings at best, or rain at worst which destroyed the cover. Full credit to the ski resorts though; they took every opportunity they could to create man-made snow and build up the base to keep the main runs healthy, but without natural falls helping out it's a tough job.

Specifically with the Victorian resorts that I visit, Mt Hotham was unable to open the Orchard area at all, and at Falls Creek the Summit/International lifts never opened either, requiring at least another 30cm of cover to open up the main runs at the Summit.

Trip 1: Mount Hotham

Our Hotham trip with friends was characterised by a wide range of weather – day 1 was clear, day 2 was raining (and very windy), and day 3 was snowing (and still very windy). Waterproof clothing was the MVP (huge thanks to my new Yuki Threads jacket I picked up in the off season!), closely followed by determination and perseverance in the face of wild weather conditions.

We had a few friends that arrived drove up one day earlier (spending the night in Bright) and enjoyed the clear weather that we got at the start of the trip. A very smart choice in hindsight. Here's a picture looking down from the top of the 'Village run' on our clearest day of the trip.

Apart from the on-piste action, I was able to take another instance of my “That Hotham Photo” – a specific section of the mountain ascent where the Great Alpine Road has this gorgeous & aesthetic bend to it:

We had a group of 10 people attend all up which I'm still super grateful for. We've been doing a Hotham trip annually for over a decade, and it's my most favourite weekend of the year. The apartment we got had a lovely south-facing view of the surrounding valleys, which is excellent to enjoy your morning coffee and avocado on toast while you work up the energy to attack another day on the ski lifts.

Stats:

• 46 runs over 3 days
• 51.8km distance
• 10,198m vertical

Trip 2: Falls Creek

My trip to Falls with colleagues & friends had a different vibe. Some of the group were people I spend my 9-5 with so I was still slightly in 'work mode', but we fortunately didn't talk too much shop during the trip. The average experience level of the group was also more novice, meaning that I often had to give advice or guidance to people who were learning their way around the mountain.

I was pleased to hear that several people wanted to try the Saturday night skiing down Wombat's Ramble. Even though I have outgrown the beginner run a long time ago, going for a few casual runs after eating some dinner was a good way to warm up the muscles and ensure my gear was set up correctly. Turns out I set up my bindings the wrong way around, so I was going down the mountain with my board pointing the wrong way! A good reminder as to why I bring a mini-screwdriver with me on the mountain...

Wombat's Ramble has this shipping container halfway down the lift that is painted differently every season, and at night they have UV lights shining on it. This year's glow-in-the-dark artwork looked epic – after I took a photo of another group of skiers in front of it, they kindly offered to return the favour for me:

In comparison to Hotham, Falls is definitely weighted more towards intermediate terrain and I didn't feel like I was massively challenged on any of the available runs. Sadly all of the black runs weren't open due to the poor snow cover, but moving around the mountain every hour or so kept things interesting throughout the day. Falls also has some excellent on-mountain food & beverage options, so you're never far from a hot chocolate or a dim sim to keep your energy levels up or just enjoy the view.

The weather during the entire trip was clear & intensely sunny, with the clouds only rolling in as we headed back to Melbourne. If I had the ability to put sunglasses on under my goggles visor, I would have!

On the final morning I enjoyed a short walk up to the village bowl before we needed to pack up the apartment and get in the van:

Stats:

• 52 runs over 2 days (+ 3 runs on the night skiing session)
• 54.0km distance
• 8,132m vertical

My personal snowboarding goals for 2026

As my skills have stabilised and I'm comfortable boarding down most runs at any ski resort I go to, I've started to give myself a little goal or objective for each season – otherwise I feel that the novelty wears off a bit and I'm not able to enjoy the activity that much.

In 2026 I wanted to start learning how to safely use the terrain park features and start doing some jumps & basic tricks, and Hotham started a beginners lesson to get the fundamentals right, especially regarding body position & technique. I had my lesson on that first clear day we had at Hotham. I really enjoyed it and it allowed me to be completely comfortable with smaller jumps and boxes. I didn't have any major falls during my jump attempts this season, but maybe that means I didn't commit enough. Something to build on for 2027...

Overall stats for 2026

I use Slopes for the tracking of my runs and I love supporting a small & dedicated team of developers, and I find the GPS tracking to be far better than any of the resort apps.

Slopes has a great feature where you can calculate whether your season pass actually saved you money or not, and a good baseline indicator is the “cost per run”. Last year I did about twice as many days on the snow and got my cost per run down to $4.50, and this year I only got it down to $7.74.

There's obviously flaws in the maths & logic – your lift pass isn't the only thing you need to pay for to enjoy snow activities, especially considering on-mountain accommodation & food – but having a calculation that's fairly consistent year-on-year is good, and rewards the people who make the most of their time on the slopes and keep pushing for another couple of runs.

2026 Stats:

• 101 runs (over 6 days)
• 105.9km distance
• 18,329m vertical
• average speed – 22.3km/h

What's interesting is the amount of downtime (the light grey part in the above image) that occurs throughout a typical day. Waiting in lift queues, meal or drink breaks, or just waiting around to meet up with people – it all adds up. I looked into my last few snow seasons and the downtime is always around 45-50%.

Looking ahead

This Aussie season will obviously have most ski bums thinking about going overseas in the years to come, and my friends & I are no different. Japan & New Zealand are the obvious contenders for us, depending on which time of year you want to visit. But over the last 5-6 years we've had 3-4 excellent seasons with all lifts opening at Australian resorts, so we can't let recency bias sway us too much.

We'll still do our annual Hotham trip next year, but doing anything more than that might be a stretch. All I know is that my body is holding up well so I'll be strapping into those bindings as long as it's capable.

#snowboarding #sports #snow

“I thought freedom would feel like coming home. Instead, I came home to a life I no longer recognized.”

The doors opened.

After three months of locked rooms, counted movements, and waiting for someone else to decide where I could go, I stepped outside.

I thought I would feel relief.

I thought the air would fill my lungs differently. That the sky would look brighter. That freedom would rush through me the moment there was no longer a locked door between me and the rest of the world.

But when I stepped outside, I felt nothing.

No joy.

No relief.

No sense of beginning again.

Just a strange, hollow distance between me and everything around me.

The world had kept moving while I was gone.

Cars passed.

Phones rang.

People hurried through their ordinary lives as if nothing had happened.

But everything had happened.

At least to me.

Three months had changed the way I moved through the world. In jail, every part of my day had been controlled.

When I woke. When I ate. When I showered. When I slept. Even silence belonged to someone else.

Then suddenly, I was expected to know how to live again.

No one told me what to do with that kind of freedom.

No one explained how to return to a life that no longer felt like mine.

When I came home, the house looked familiar.

The same walls.

The same furniture.

The same rooms waiting where I had left them.

But something was different.

Maybe it was the house.

Maybe it was me.

I stood in the doorway and looked around like a stranger who had been given someone else's key.

This was supposed to be home.

So why did I feel like I didn't belong there?

The house swallowed me whole.

I moved from room to room, but it didn't matter. Each corner felt the same.

Heavy.

Stale.

Unfamiliar.

The air hummed with stillness, but not the comforting kind. This silence scratched. It pressed against my skin like static.

The walls seemed to lean inward, shrinking the space around me. Even the light looked duller, as if it were tired too.

I thought I had wanted to come home.

But once I was there, I couldn't stand being inside it.

Every room held a memory of the life I had lost. Every quiet corner reminded me of who was missing.

The couch, the kitchen, the hallway, all of it belonged to a version of my life that was gone.

So I wanted to leave.

But whenever I imagined going out, panic rose inside me.

In public, I felt exposed.

I imagined people staring at me.

Judging me.

Knowing where I had been.

Knowing what had happened.

I couldn't tell whether anyone was actually looking or whether I had simply forgotten how it felt to exist without being watched.

Home felt unbearable.

The outside world felt impossible.

I didn't want to be anywhere.

That was the worst part.

There was no place where I felt safe. No room where I felt like myself. No direction I could move that didn't lead back to the same pain.

So I stayed on the couch.

Hours passed without me noticing.

The clock ticked, but I didn't feel time anymore. Morning bled into afternoon, afternoon into night, and night into another morning.

The days blurred together until I couldn't tell one from the next.

I had imagined freedom as movement.

Instead, I became still.

I stopped answering messages.

I stopped returning calls.

Some days, getting dressed felt impossible. Other days, I put on clothes and stood by the door, unable to make myself open it.

I didn't know what was happening to me.

I only knew that I hated being awake.

I hated the silence.

I hated the memories.

I hated the way everyone else's life seemed to continue while mine remained trapped in the same moment.

Some mornings, I opened my eyes and felt disappointed that another day had begun.

I didn't know how to help myself.

I didn't know how to explain what was happening inside me. I had survived jail. I had survived the courtroom. I had survived hearing myself described as someone I did not recognize.

But I didn't know how to survive being free.

My daughter barely talked to me.

I heard her voice through a closed door, laughter spilling out for friends, soft confessions whispered into a phone. She still knew how to laugh.

Just not with me.

When she looked at me, her eyes were guarded. Her words were short, clipped, careful.

I wondered if I had become someone she no longer wanted to claim.

The thought cut deep, but I couldn't blame her.

Most days, I didn't want to claim myself either.

My children carried a weight I never meant to hand them. They didn't say they blamed me, but shame filled in everything they left unspoken.

Maybe they were angry.

Maybe they were afraid.

Maybe I was only hearing my own guilt in their silence.

Either way, I felt as though I had failed them.

I wanted to tell them I was proud of them. I wanted to tell them I saw how strong they had become.

But the words stuck in my throat.

Part of that strength had come from necessity. They had grown up faster because I had fallen apart.

That was a truth I didn't know how to carry.

Even my dog seemed to feel the difference.

He used to greet me at the door, tail wagging, spinning in circles as though I were his whole world.

Now he lay with his head on his paws, watching me with eyes that seemed too knowing.

At night, he curled against me as if he were trying to anchor me.

I felt his heartbeat pressed against mine.

Steady.

Loyal.

Alive.

Sometimes, he was the only reason I moved at all.

I existed in those rooms, but I wasn't living in them.

I didn't laugh.

I didn't smile.

I couldn't remember what either one felt like.

I used to love music. Now every song hurt.

I used to love cooking. Now the smell of food made me sick.

I used to disappear into books. Now the words blurred before I could turn the page.

Everything I once loved seemed to belong to another woman.

A stranger.

Someone who had lived in this body before it became numb.

And while I sat inside a life I no longer recognized, he seemed to be building a new one.

The jealousy ate at me.

He was laughing while I was sinking.

Why did he get to be happy?

Why did he get to walk away from the pain while I drowned in it?

How could he give someone else the laughter, the tenderness, and the promises I had spent years begging him to give me?

I hated myself for caring.

But I cared.

You should let him go.

But I couldn't.

You shouldn't want him anymore.

But some part of me still wanted the man I had believed he was.

I became both the jailer and the prisoner, locking myself inside the memory of him.

Sometimes I thought about meeting someone new.

The thought appeared like a match flickering in the dark.

Small.

Fragile.

Almost hopeful.

Then fear came and blew it out.

I didn't know who I was anymore. I couldn't imagine showing this version of myself to another person.

What if they saw what I saw?

Tired.

Used up.

Empty.

What if I wasn't enough?

What if I was too much?

Dating felt like another world, one I no longer belonged in. I didn't know what I would wear, what I would say, or how I would explain the pieces of my life.

I couldn't even look in the mirror without flinching.

So I told myself I didn't want anyone.

But that wasn't the truth.

I wanted to be loved again.

I wanted to feel safe inside another person's arms.

More than that, I wanted to feel safe inside myself.

And wanting any of it terrified me.

I opened my notebook and wrote down the questions I couldn't say aloud:

When is it the right time to begin again?

How do you know when you're ready?

What if no one ever wants me?

What if this emptiness is permanent?

What if this is all that's left of me?

The words stretched across the page, shaky and uneven.

At night, sleep wouldn't come.

Whenever I closed my eyes, the images were waiting.

Him.

Her.

His mother's laughter echoing through the courthouse.

The cell.

The judge.

The locked doors.

Over and over.

I turned on the light.

I scrolled through my phone.

I tossed.

I turned.

The night stretched on forever.

When sleep finally came, the dreams weren't kinder. I woke gasping, the sheets twisted around me, my dog nudging me with worried eyes.

Then another day began.

The same heaviness.

The same silence.

The same ache.

This was the deepest depression I had ever known.

It wasn't only sadness.

It was disconnection.

From my family.

From the world.

From the woman I had once been.

I didn't know how to find her.

I didn't know whether she was still there.

But somewhere beneath the numbness, one small desire remained.

I wanted to be happy again.

I wanted to feel loved again.

I wanted to feel whole.

I didn't know how.

I didn't know when.

I didn't know if it was possible.

But I wanted it.

And maybe wanting was the first step.

That night, I opened my notebook and wrote one sentence:

I want to be whole again.

The letters were shaky.

Almost unreadable.

But they were mine.

I closed the notebook and pressed my hand over the cover as if I were protecting a fragile seed.

It didn't feel like enough.

But it felt like something.

(NEXT – CHAPTER 16: FRAGMENTS)

#In Summary: * Two things: firstly, spent an hour this morning at yard work, did some light trimming on the front lawn, looks much better out there now and the work didn't wipe me out; and secondly, I've cancelled my NFL subscription. Their broadcast product no longer interests me. They're Much More oriented toward gambling than the game of football. All I want is good play-by-play game coverage, and I can usually find that for free for most games after doing a little scouting around on the Internet.

Prayers, etc.: * I have a daily prayer regimen I try to follow throughout the day from early morning, as soon as I roll out of bed, until head hits pillow at night.

Health Metrics: * bw= 225.53 lbs. * bp= 139/81 (70)

Exercise: * morning stretches, balance exercises, kegel pelvic floor exercises, half squats, calf raises, wall push-ups, BP breathing exercises, pilates

Diet: * 06:30 – 1 peanut butter sandwich * 11:30 – chicken lasagna * 12:45 – 1 fresh orange * 16:30 – sponge cake

Activities, Chores, etc.: * 03:30 – listen to local news talk radio * 04:15 – bank accounts activity monitored * 04:45 – read, write, pray, follow news reports from various sources, surf the socials, nap * 09:00 to 10:00 – yard work, lightly trim front yard * 10:20 – watching Good Morning Football * 12:30 – watch old game shows and eat lunch at home with Sylvia * 15:00 – listening to the Countdown to Kickoff Show on Steelers Nation Radio ahead of tonight's preseason NFL game, Steelers vs Jets

Chess: * 11:00 – moved in all pending CC games

By the time sentencing came, I had already spent three months in jail.

Three months with nothing but time to think about how my life had ended up here.

Three months replaying every message, every moment, every decision that somehow led to this courtroom.

But nothing prepared me for hearing him speak.

When the judge asked if he wanted to say anything, he stood up and began describing someone who he had created in his mind.

He said he was afraid of me.

He said he didn’t feel safe if I was released.

He talked about me like I was violent, unstable, someone who had ruined his life.

At one point he started to cry.

I sat there stunned, listening to the man I had spent twenty years loving paint a picture of me that simply wasn’t true.

The woman he was describing wasn’t the person who had built a life with him.

She wasn’t the mother of his child.

She wasn’t the woman who had spent months trying to understand why he had disappeared without a word.

She was someone else entirely.

A character in a story he needed the judge to believe.

And as I listened, something inside me shifted.

For months I had been trying to understand him.

Trying to explain his behavior. Trying to find a reason that made sense of the silence, the accusations, the way everything had turned against me.

But sitting in that courtroom, hearing him speak, I realized something I had been avoiding.

This wasn’t confusion. It wasn’t misunderstanding. It was intentional.

The story he was telling protected him.

If I was the unstable, dangerous ex, then he didn’t have to explain anything else.

Not the affair. Not the silence. Not the manipulation. Not the choices he had made.

In that moment, I wasn’t seeing the man I thought I loved.

I was seeing the man he actually was.

And that realization hurt more than anything that had happened before.

Because the person I had spent years defending didn’t exist in that courtroom.

The man standing there had already decided who I would be in his story.

And no matter how many lies he said that day, one truth finally became clear to me.

The woman he described in that courtroom wasn’t me.

And maybe, for the first time in a long time, I didn’t need him to see the difference.

REFLECTION

THAT DAY TAUGHT ME THE TRUTH, IS NOT ALWAYS FOUND IN WHAT PEOPLE SAY.

SOMETIMES IT REVEALS ITSELF THROUGH WHAT THEY ARE WILLING TO DO.

I COULDN’T CONTROL THE VERSION OF ME. HE PRESENTED IN THE COURTROOM.

I COULDN’T FORCE HIM TO ACKNOWLEDGE THE YEARS WE HAD SHARED OR THE WOMAN I KNEW MYSELF TO BE.

BUT I COULD STOP LOOKING TO HIM FOR CONFIRMATION OF MY OWN REALITY.

THE JUDGE HELD MY IMMEDIATE FUTURE IN HIS HANDS, BUT MY IDENTITY WAS STILL MINE.

I DIDN’T LEAVE THE COURTROOM HEALED OR FREE FROM FEAR.

I LEFT WITH SOMETHING SMALLER QUIETER, AND PERHAPS MORE IMPORTANT.

THE UNDERSTANDING THAT HIS STORY ABOUT ME DID NOT HAVE TO BECOME THE STORY I TOLD ABOUT MYSELF.

THAT DAY MARKED THE END OF ONE CHAPTER.

NOT BECAUSE THE PAIN WAS OVER, BUT BECAUSE I HAD FINALLY STOPPED, ASKING THE PERSON WHO WOUNDED ME TO EXPLAIN WHO I WAS.

(NEXT – CHAPTER 15: HOLLOW)

Our Father Who art in Heaven Hallowed be Thy name Thy Kingdom come Thy will be done on Earth as it is in Heaven Give us this day our daily Bread And forgive us our trespasses As we forgive those who trespass against us And lead us not into temptation But deliver us from evil

Amen

Jesus is Lord! Come Lord Jesus!

Come Lord Jesus! Christ is Lord!

The apiary be Scottish run to mute Late December this hugger And seeing simply rise What time in Hearst for Will Enough of oak And seeming simpler For five octet and lane And pasture by the law Economy forever- and nines to the Moon Giving ray to God And night shall let us be- the end of war.

A Benediction in Christ

Sound out the early years Be humbled by God This is His Grand Season Fear not any judge, but In hand keep session- The care of others truly Be supplicants of joy Raise tidings to Heaven Reap the later harvest- And sow in yearly time At attire, be in grace These are tenets of the EU- Your days and the world Rolling up maps of your neighbour- Let him in.

The kindness and longsuffering of Women- In war and peace, recognize and relieve

Peace to all animals, shepherds, and life in the seas.

Forgive others- And be just in your decisions Lend Heaven to all.

Pray against war, and serve victims as if royalty. Be well and steadfast, humble, and true,

We pray in Christ Jesus,

Amen

OpenBSD

How I’ve grown Layers of travel to each quantum bit In parity,- a desk drawer Lighting chances to be fate,- I love what I have found Nothing to censor and I believe- The surest bet is OpenBSD Waves of cool choices like time,- Nothing to expend- Taking the reins that we will be together Horses drawn and the wheel ready I want on that USB The Romans were here and stole our code Ready-made stuff Thoroughly imbued what’s important Home for the living- Having bettered our world- to join.

Vlad (part six)

Alight in fever As this day long and better The white man was there And the French are the poor For settling the highs And light pollution our thread For the sins of the father We made it one day And cryptic to him The Earth was created to empire For all we explore As doorbells to fire And they see No hope in rain But the heights of East Fire Ebola these firsts And where they are, I cope To trail with a summons The Earth is strong And scourge, and infirm The maddest reply For history the ruler We rhyme calcitrant- when they call Our African view And his ninety year end The likes of me Places at noon Pre-tensile and needy A thousand yard realm Of steady proper And waiting for dawn The dust by our engines A small thought for noon By the lakeside And the memory That time is without us A stale intervention If we shore up the herds And prophecy seeing No place to hide And low sales And a victory at war For Korea the near And expressed Our enemy of never Never Kate or the picture We stashed all align This courtesy sharp Only castles to bear And history before that I was long to before And why I don’t drink On a date with the hero By generation be better As I flew to Kiev The licensure plane To better my options Accepting the ruse And the rule And for treason Alight for the town And dressed just the same To Chernobyl.

Thank you for singing for me. Thank you for taking me to the rocks so I remember where I am from. Thank you for making me jewelry. Thank you for seeing the light in me and for seeing beyond what I saw in myself. Thank you for telling me that. Thank you for trusting me despite how little we know about each other in earthly ways. Thank you for sharing your wisdom with me. Now go home to the rocks where there’s nothing but peace, love, and music. I hope you get to relax. I hope they see you for who you are. I hope you sing again.

Stop me if you’ve seen this one before. A big old house, Victorian, ideally, with too many rooms on too many floors, and loads of dark wood paneling. Faint eerie sounds and brief glimpses of vague unsettling shapes. Lights and electrical devices that flash or fail at the most inconvenient times. Objects that move or morph without visible causality. Poorly lit spaces that suddenly and randomly require dozens of lit candles. Artifacts or personal items that go missing only to reappear later in other spaces inexplicably. A priest, psychic, or some other spiritual medium as witness and guide. A jump scare every 8 minutes or so.

These are just some elements of the often formulaic production of a typical horror movie these days, filled with pastiche and tropes. Taken together, they can be entertaining in the same way a haunted house at a local carnival can. But some will likely confuse their entertainment with reality and mistakenly believe or imagine that what they see on their screen accurately portrays real experiences with the liminal, uncanny, or anomalous.

Now, granted, what people consume as entertainment should never be confused for reality, even when ambiguous claims are sometimes made stating a work is based on “actual” or “true events.” Horror films are not documentaries, and they don’t purport to be, although some documentaries can be horrific and terrifying. Yet, I’ve always felt that confusing or conflating such things with someone’s actual lived experience doesn’t do anyone any good. If anything, it harms.

And that leaves me with a sense of grief mixed with frustration.

---

There’s a kind of desecration at work when the entertainment industry, or any industry, actively works to exploit the experiences of others’ inner lives where phenomenological encounters are reduced to quick audience shrieks, graphic spectacle, and the all-too-consumable “creepy” aesthetics in the way that something sacred and profound is cheapened when it becomes a commodified product. Pimping spirituality should feel icky because it is not a victimless crime. The harm is that those who have experienced the uncanny and anomalous become invisible—even irrelevant. And the lifeless derivative shell becomes accepted knowledge and mindset for the masses to devour and inhabit. A poor artifice of lived inner experience. An illusion of truth.

The non-material deserves just as much serious attention as the material. Subjective experience deserves rigorous, multidimensional engagement rather than the petty scoff that accompanies easy dismissal. Modern society’s reflex to pathologize, religionize, trivialize, or force such experiences into reductive binaries such as “either it’s scientifically validated, or it’s nonsense” is a failure of the imagination and a failure of a basic understanding of the human condition. It forecloses the possibility that reality might be stranger, more complex, layered, and nuanced than what consensus allows. The result is isolation for people with unusual experiences.

But I’m not someone who demands everyone share my ontology, cosmology, and point of view. My objections against the entertainment industry and pop culture regarding the uncanny aren’t that either one gets the metaphysics wrong. Rather, it’s that these are the dominant modes of representation, whether it’s horror, parody, New Age commodification, mega church evangelism, clinical reductivism, etc. They all share a refusal to simply sit with and listen to anomalous experiences on their own terms without defensiveness, diagnoses, or dismissiveness. By avoiding, deflecting, or outright denying the unusual experiences of others, we cater to the popular consumption of ideas that misrepresent what may be a key, critical facet of our reality and existence. Such reframes do a disservice to individual experiences and humanity as a whole.

---

We need, then, some kind of middle ground between these competing extremes, especially in this age of willful ignorance and systemic mass media manipulation and deception. I’m not suggesting compromise. I’m suggesting active listening and openness to what we may not agree with or can't easily categorize, without rushing to judgment, reflexive explanation, or mining for entertainment fodder.

There’s no way pop culture will do this kind of work. It has evolved for a different purpose entirely and cannot be commandeered to do otherwise. But for those of us who have slipped into, or even past, liminality and remember what we’ve seen, heard, touched, and felt, we can at least refuse to participate in the further flattening of our reality. We can unapologetically hold our truth in the face of those who would rob us of our dignity. And we do that by keeping our hands, minds, and hearts open.

So by all means, let’s enjoy the next horror flick. But when we do, maybe ask ourselves if our own lived experience might have just become someone else’s entertainment.

Winter in August. A turtle dove sings alone

#haiku

Hablar de política es hablar de poder. Esto puede parecer una perogrullada para algunos, pero la polisemia de la palabra “política”, que además está llena de matices, puede llevar a graves malentendidos.

En primer lugar, ¿de qué política estamos hablando? En este caso, entendemos por política la actividad destinada a la toma de decisiones colectivas, es decir, la gestión de conflictos. Sabemos que el conflicto es inherente a las sociedades humanas, por lo que debe ser considerado como un fenómeno natural dentro de ellas.

Un esbozo de marco conceptual

En este contexto, dado que el surgimiento de conflictos parece inevitable, surge una incertidumbre respecto al futuro. Dicho de otro modo, si en cualquier momento pueden aparecer problemas de convivencia social, el statu quo no puede permanecer inmóvil ni invariable. El conflicto, o la amenaza del mismo, genera cambios en las circunstancias, lo que hace necesario lidiar con nuevas condiciones.

Para establecer la relación entre esta definición de política y el poder, es necesario aclarar también qué entendemos por poder. Dentro del contexto político, el poder tiene dos elementos clave: la autoridad, es decir, la capacidad de garantizar la obediencia, y la legitimidad, que es la aceptación de dicho poder por parte de la comunidad. En el contexto actual, la política se hace desde o a través del Estado(1) y este es el que ejerce el poder, para ello hace uso del monopolio de violencia para ejercer su autoridad y de la estructura democrática, en sus distintas formas, para henchirse de legitimidad.

Un ejemplo típico de la relación entre poder y política se encuentra en la educación primaria. Existe un consenso social, ya sea implícito o explícito, de que la educación primaria es tanto un derecho como una obligación. Por tanto, los niños hasta cierta edad deben asistir obligatoriamente a un centro educativo para ser instruidos. Incluso si esto va en contra de la voluntad del menor o de sus padres. En el Estado español es el Ministerio de Educación y Formación Profesional el responsable de diseñar el currículo que dicta los contenidos de ese aprendizaje forzoso.

El caso valenciano

Muchas regiones del mundo, como es el caso de Francia, buscan eliminar cualquier lengua distinta de la oficial para así crear una identidad homogénea en el Estado que legitime su territorio como unidad política inalterable. Por suerte, en España estas lenguas gozan del estatus de cooficiales, es decir, son lenguas que deben tener el mismo rango de oficialidad que el castellano dentro del territorio regional. Retomando el currículo educativo, esto introduce un componente lingüístico en la gestión educativa. No todo el currículo escolar está redactado por el Estado central, sino que se cede cierta competencia a los organismos regionales de las diferentes comunidades autónomas. La decisión de qué lengua y en qué proporción se enseña durante la etapa primaria de la educación en cada región es un reflejo directo de la intervención del poder político en la gestión de este conflicto.

Un caso especialmente interesante es el del País Valencià, donde en la educación primaria se enseñan dos lenguas: el castellano y el catalán. En esta región, existe una legitimidad tradicional para que los niños aprendan catalán, ya que es una lengua de arraigo histórico y uso habitual en gran parte del territorio. Al mismo tiempo, al estar esta comunidad dentro del Estado español, también existe una justificación legal-racional para que todos los niños aprendan castellano. Se ha generado una situación de bilingüismo territorial que ha sido y sigue siendo fuente de fuertes tensiones sociales y un campo de batalla político. Lo que lo convierte en un ejemplo relevante para este análisis.

Extensión del Valenciano en la Comunidad Valenciana. fuente: Joan M. Borràs (ebrenc), CC BY-SA 2.5, via Wikimedia Commons.

No solo eso, sino que existe una peculiaridad más dentro de València: no todo su territorio es de tradición catalanoparlante. En algunas zonas, históricamente, nunca se ha hablado esta lengua. A pesar de esto, la Ley 4/2018 aprobada por la Generalitat Valenciana, establece un mínimo de horas de enseñanza en valenciano. Esto implica que en áreas donde nunca se ha utilizado esta lengua de forma habitual los estudiantes deben aprenderla ineludiblemente.

La legitimidad en este caso es más difusa, no se puede justificar en la tradición. Lo que sí existe es la autoridad de la Generalitat, por los poderes conferidos por parte del Estado, para llevarlo a cabo e imponer este currículum en las escuelas. Este proceso refleja el ejercicio de poder político a través de la regulación educativa y la autoridad para imponer decisiones que afectan a la población.

La imposición en este caso parece un proyecto a largo plazo: un intento de crear esa homogeneidad lingüística —de inspiración francesa— en todo el territorio, que dote de cohesión identitaria y que, con el tiempo, genere aceptación y, con ella, legitimidad.

El cambio de gobierno y la consulta a las familias

Sin embargo, con el cambio de gobierno hubo un cambio en la política lingüística. Ahora ya no hay “mínimos”. Sin embargo, si con la ley anterior podíamos ver la capacidad de imposición del regulador ahora podemos ver el uso de la democracia como legitimador para, una vez otorgada esa legitimidad, ejercer su proyecto político con independencia del deseo de cada centro y familia.

Me refiero a la famosa consulta a las familias, que fue una votación en la que se pedía a los tutores de los alumnos votar qué lengua será aquella en la que se impartirán las clases, si castellano o valenciano. Como adelantaba, esto tan solo es un legitimador pues, en la práctica, institutos con mayoría de votos a favor de usar el valenciano como lengua vehicular siguieron dando las clases en castellano.

¿Y otras asignaturas?

Para contextualizar mejor la naturaleza del poder político en el ámbito educativo, resulta ilustrativo comparar esta situación con la regulación de la asignatura de religión. De acuerdo con el Real Decreto 243/2022, al principio del curso se debe dar la opción a las familias de cursar o no la asignatura de religión. En el caso de que una sola familia en todo el centro elija cursar religión, se fija la obligación del instituto de garantizar que el alumno podrá asistir a dicha asignatura.

Esta comparación revela una asimetría significativa en el ejercicio del poder político: mientras que la demanda lingüística expresada democráticamente por una mayoría de familias puede ser ignorada en la práctica, la demanda religiosa de una sola familia genera una obligación ineludible para el centro. Asimismo, la fijación del currículo de religión no corre a cargo del instituto, ni de la Generalitat, ni siquiera del Estado central: es la propia confesión católica quien decide los contenidos de la misma. El contenido de la asignatura Valenciano no lo decide una autoridad lingüística o filológica, sino que es marcado por la Generalitat Valenciana, lo cual ha propiciado la aparición nuevos conflictos.

Conclusiones

El análisis del caso valenciano nos permite observar cómo el poder político se manifiesta en la regulación educativa a través de distintos mecanismos: la imposición normativa, la consulta democrática como fuente de legitimidad y la aplicación selectiva de los resultados de dicha consulta. La comparación con la asignatura de religión revela, además, que la autoridad y la legitimidad no operan de manera homogénea, sino que se despliegan de forma diferenciada según los intereses en juego.

El conflicto lingüístico valenciano, lejos de ser una simple disputa educativa, constituye un ejemplo paradigmático de cómo el poder político gestiona —o deja de gestionar— las tensiones inherentes a toda sociedad plural.

---

1 – Uso aquí la concepción weberiana del Estado como conjunto de personas que ejerce la dominación sobre otras personas mediante la violencia legítima. Se encuentra desarrollada en varios de sus libros. Muy explícito al respecto es El político y el científico.

Nota: El valenciano es la denominación estatutaria e histórica de la lengua catalana en el País Valencià. A lo largo del artículo se utilizan ambas nomenclaturas indistintamente.

#Artículos