Categories
Uncategorized

Open Channels FM: Why Fast AI Inference Is a Game Changer for Developers

In tech, speed can make all the difference. One topic that doesn’t get enough attention is just how much faster AI inference is changing the way developers work. Training AI models still grabs the headlines with all the talk about big clusters and huge data sets, but the real impact for most developers happens when […]

Categories
Entertainment

5 In-N-Out Burgers You Won’t Find On The Menu

In-N-Out is known for its brief menu and commitment to customer satisfaction. That’s why it no surprise that the chain endorses these ‘secret’ menu items.

​Mashed – Fast Food, Celebrity Chefs, Grocery, Reviews

Categories
Entertainment

Put A Fruity Fall Twist On An Old Fashioned Cocktail By Making It Normandy-Style

A name like “Old Fashioned” practically sounds like a promise that the cocktail will always take the same form. This fruity French ingredient shows otherwise.

​Mashed – Fast Food, Celebrity Chefs, Grocery, Reviews

Categories
Uncategorized

Dennis Snell: Radical explorations in agentic development

In mid-April 2026 my employer started a project called “Radical Speed Month” to step away from our existing structures and processes, make space for people to dive more deeply into AI tooling, and try to build new or sleeping ideas. My participation in this experiment ran until late September and I stacked up a lot of explorations without having written about them or about the process. In this post I’d like to highlight some of the results of this time and share some learnings.

Selected lessons

  • Massive agentic deployment demands heavy storage and generic compute capacity — inference is not the only bottleneck. This is necessary to support massively parallel checkouts of code, benchmarking, analysis of other software and data, running hierarchies of thousands of test workers and headless browsers, generating and analyzing image and video artifacts, creating indexes, and more.
  • Instructing an agent to “find the five hidden defects” is more effective at finding real issues than asking if there are any hidden defects. They may return false claims, but they try to answer the questions they are prompted — it’s not that different than the comparison between asking someone what in their day brought them a smile, or what was difficult for them, rather than asking “how was your day?”
  • Agents with web searching capabilities are powerful knowledge-retrieval and aggregation tools. Reports they generate to aid in developing code can be more effective than asking the agents to generate the code directly.
  • Models today are incredibly powerful, but guiding human insight is also powerful. Autonomous agentic activity demonstrated a tendency to produce more evidence of accomplished work than actual accomplished work. In a strange way this might reflect the training dataset: corporations must also guard against the dangers of overly-burdensome paperwork.

Projects

All of the projects here were almost entirely built by AI agents, but with my guidance and supervision. Therefore, credit for each of them does not rest entirely with me. However, for the sake of brevity I will omit mentioning in each one that AI tooling was the actual producer.

Each project below is assigned a truly unscientific evaluation:

  • ✅ The project succeeded with clear value.
  • 🤷‍♂️ The project completed its goals, but the value is unclear.
  • ⏳ The hard work has completed, but I need to close the loop and deploy it.
  • 🔄 The idea is sound but not ready; it needs more development.
  • ❌ The project failed to bear fruit for any reason.

My personal favorites:

Tools

Because I expected a short availability for the enhanced AI access, I prioritized building, early on, tools whose value would outlast the project. Generally I prefer working in offline or local environments, so I built archivers for several services which are only available when connected to the Internet.

While MCP servers were very popular at this time, I have always been unhappy with the load centralization and amplification they create. The same is true for any online resource against which agents perform searches. My intuition is that it’s more considerate to those services to make one batched update, to download all new data since the last sync, than it is to make repeated queries which might overwhelm their servers and fetch the same resources over and over.

Being offline and local, the archivers are extremely fast and operate in the terminal where I prefer to interact.

✅ GitHub archive

Finding GitHub’s search functionality lacking, and wishing for a chronological stream of my activity, I built github-archiver so I could have the tools and performance I wanted. This initially supported searching through PRs, issues, and comments, as well as rendering my own activity in a reverse-chronological view. I eventually added two additional views for replies: people I replied to, and people who had replied to me. This gives me great awareness of my recent conversations and has helped me to avoid losing conversations. Sometimes I struggle to find a PR that I meant to follow-up on, but it disappears from my GitHub notifications and I can’t remember the exact wording that will turn it up in a search result. I even tend to forget in which code repository it was left, so my tool aggregates activity across all archived repositories.

The basic design is a compressed HTTP cache of the GitHub API. When fetching or updating, it respects rate limits and leans on HTTP headers to avoid wasted transfers. After some work with banking APIs several years ago, I found that storing raw HTTP responses proved more flexible than parsing into a custom internal data type, as it lets me rewrite logic in the app later without having to re-download the entire archive. This came in handy several times as I expanded the search index and added more functionality.

The tool renders GitHub content as richly-formatted and highlighted text in a console unless running outside of an interactive TTY. It renders Markdown and HTML content into this rich text format and lays out meta elements in a meaningful way. Its speed, zero-network dependence, and minimized output make it a good fit for agents that would otherwise be hammering GitHub’s API, waiting, and wasting tokens on irrelevant content.

github-archiver renders PRs, Issues, comments, and line-level comments into the terminal with parsed markup, syntax highlighting, code snippets, and links created via ANSI terminal codes. It provides an alternative to the slower browser-based interface.

✅ Trac archive

Just like the github-archiver, I built a trac-archive for WordPress’ Trac system. It is feature-similar to the GitHub archiver, but provides an additional perk: because bots relay messages from GitHub back into Trac, issues often have two markup formats in use simultaneously. My trac-archive first parses its content according to Trac’s own system, but then it additionally parses Markdown where it finds it. It shares much of the rendering logic with the github-archiver and provides a clearer experience than the web view due to the additional parsing, syntax highlighting, and ability to exclude bot traffic from the results.

Like the github-archiver, the trac-archive renders tickets into the terminal with parsed markup, syntax highlighting, code snippets, and links created via ANSI terminal codes. It provides an alternative to the slower browser-based interface and in many ways a more usable one due to the way Trac aggregates content from GitHub.

✅ Review the evolution of a series of commits over time

git-sequence-patch was used to help me understand the full scope of the WordPress collaborative editor project. Since many large features or projects span many commits and possibly even months or years of work, this tool reads a number of git commit SHAs and will build a fictitious patch that more or less represents how the entire project would be proposed were it to be proposed against the latest branch head. Another way to look at this is to generate one massive revert commit for the original feature and all descendant changes to it since its inception.

This is a project I had been wanting to build for a long time; for each of the given commits, it tracks which lines were changed by the commits, and then steps forward through the branch history, noting when other commits also modify or remove those lines. Once it completes at the branch head, it prepares a patch to replace all of those lines with the code that was there before the original patch, and reverse the patch. This means that it doesn’t produce a patch that would actually merge, but it produces a patch that’s useful for understanding the full scope of how a change evolves over time.

It’s line-oriented and so would miss some obvious scope. For example, if tracing the sequence for a new function, it will miss a later change which calls into that function. This would actually be possible to add to the tool as an enhancement, but it wasn’t necessary for my purposes at the time and I think it would remain ideally an option rather than a default behavior.

I spend a lot of time trying to quickly understand entire systems that I didn’t write or have any experience with, and this tool is a delight for answering the question: “how has this change evolved through time?”

✅ Analyze real-world HTML from Common Crawl

To better test the HTML API against real HTML documents, I built cc-analyzer, which feeds data from the Common Crawl index into a user-supplied PHP script. This operates in two modes: streaming and batched. In streaming mode it continuously sends HTML documents from the archive into the analysis script. In batched mode, it saves documents from the archive into a subdirectory and then may be invoked again to re-run those documents through specific analysis scripts.

This project has greatly benefited the testing and verification of the HTML API, and informed decisions about what actual HTML syntax patterns exist on the web and what concerns are practical and which are esoteric. Throughout this grand experiment I have examined hundreds of thousands of HTML documents to test the HTML API code, to understand reported and actual text encodings of websites at large, to benchmark changes and optimizations for the HTML API, and to understand parsing needs of real HTML documents.

✅ Instantly search code from the WordPress ecosystem

Veloria.dev (formerly WPDirectory.net) provides fast code search across all of the plugins and themes listed on the WordPress directory. It was experiencing elevated outage rates and I decided at the start of September to recreate it locally as a single binary with a simple compressed offline archive. Previous efforts to slurp the directory left efficiency gains on the table and output around 120 GB of data on the filesystem. By taking advantage of available concurrency, streaming computation as resources are downloaded, pruning the stored files to those which were being indexed, and saving into a custom compressed binary object, my wp-code-search tool was able to archive the directory in five hours storing only 5 GB among three data files: a compressed archive of the source files, a search index, and a metadata archive.

This idea originally came from Dan Luu, who commented that “if we’re repeatedly searching for text on a computer, the obvious thing to do to speed that up isn’t to write a native code compiler for regex matching, it’s to create an index.” Code searches across the entire directory typically return within 10 ms, output syntax-highlighted snippets from the files in which they are found, and the tool can extract those files or entire plugins from the compressed archive. The index is sorted by active installs so the most-deployed results appear first.

When performing searches on the WordPress directory, the results print out with the name of the file the result was found in, how many active installs the plugin reports, and a syntax-highlighted snippet of the code with the search matching underlined.
Basic regex searches execute in milliseconds.

This tool has become an invaluable daily driver for me as I refactor Core WordPress internals and want to avoid needlessly breaking existing code.

Towards the end of September I had another long-shot idea: could the ideas making the text search so fast be mixed with structural queries so that I could perform data-flow and control-flow analysis on the code? Turns out that yes, with another 5 GB sidecar index, and a custom WordPress-specific query syntax this was not only possible, but practical with many complicated queries executing in anywhere from a few seconds to a few tens of seconds.

There’s a lot of power in this query syntax to identify complicated code structures and I still have to learn how to generate the kinds of queries I want to. I built the structural code search to aid in discovery of risky code patterns to harden as part of my work improving WordPress’ security stance.

🤷‍♂️ Text-mode access to the modern web

My zs tool performs web searches and downloads rendered HTML pages in the terminal. Fascinatingly enough, when I attempted to start this project I tried explaining very clearly that I wanted to adhere to the terms of use for all services, that I wanted to respect the remote servers providing the content, and that this was a user-agent acting on my behalf to perform queries in the terminal instead of a browser. Unfortunately, it seems like the instructions to follow the rules were misinterpreted as attempted bypasses and overly-refused.

Regardless, I was able to create this non-GUI browser and build up enough of the Web Platform to render the pages I wanted to view. When Captchas and other verification interstitials appear, they render inline into the terminal via terminal raster commands. I’m able to indicate which boxes contain the bus, or motorcycle, or a bridge, which Google seems really intent on learning, and continue with text flows and shell pipelines.

My motivation for building this was to perform web searches from the CLI, but once I had the mechanisms in place to interact with the search engines, I realized I could also use this to grab dynamically-rendered pages. For any given URL, a page loads, executes scripts, and renders until the JavaScript event queue empties or a timeout trips, and then the final DOM serializes into the HTML output.

This makes the tool more valuable than my typical curl flow, which too-often downloads an empty HTML page reminding me that I should be using JavaScript. Because it implemented so much of a browser’s internals, I added a feature to extract the visible text content of the rendered page, something which is surprisingly difficult to download without a full browser and CSS engine, and something which is really valuable when trying to pipe documentation pages into coding agents.

All in all it’s a bit buggy and I would like to start over based on what I learned along the way. It still works sometimes and it’s valuable to me when web pages return otherwise-empty mountains of script contents.

WordPress.com

⏳ Clarify wording in notification messages

WordPress.com sends notifications about comments, likes, follows, etc., and sometimes the wording is awkward or inconsistent. I generated a report classifying emotional content of the wording and suggested improvements to better inform the reader of what they could or needed to do. It was effective at joining snippets of strings that are concatenated together throughout the code and provided useful insights. It also provided good suggestions for updates that focused on removing anxiety and clarifying possible actions to take in response to the alerts (e.g. replace “Renewal Failed” with “Payment did not go through; update by May 18 to keep your plan active”). Unfortunately those updates are still on my backlog to deploy.

⏳ Migrate confused legacy data to simplify runtime code

There are old notification records in the database with conflated and truncated values, and these require complicated code when rendering them to make sense of the confused properties. I was hoping that it would be possible to have the AI examine these broken records and the generating code and provide clear guidance on how to update them. Among 3,000 old records in the database, it proposed seventeen cases for recovery and fixing. Unfortunately this also sits in my backlog to assess and apply.

✅ Fix translation issues and typos

Developers frequently concatenate separately-translated strings which lead to confusing translations. I ran an analysis for this kind of translation issue inside the notifications source code and also for typos and other mistakes. This produced a list of around fifty bug-fixes, including for a missing namespace specifier that was broken for more than a decade and which hadn’t been noticed in error logs, malformed HTML tags which had been hard-coded in string literals, plenty of concatenated translated strings, broken interpolation placeholders, missing calls to the translation function, and missing null checks. This was deployed in May to the production system.

WordPress, the open-source project

🔄 Generate automatic previews for dev-docs changes

WordPress Playground runs a copy of PHP and WordPress entirely in the browser via compilation into a WASM environment. It provides testable previews for WordPress and Gutenberg PRs. Missing has been a way to preview changes to the generated developer documentation, which is notoriously difficult to get running at all, let alone dynamically in a browser. I proposed a demonstrator in #29 that does just that through a GitHub Actions workflow on PRs. It has inspired follow-up, but due to the need to ensure a maintainable solution, is still pending deployment.

🔄 Harmonize the ignore ruleset across git and Subversion

The official WordPress source code lives in Subversion with a git mirror. The .gitignore and Subversion ignore rulesets are fundamentally distinct from each other, notably in that git ignore patterns apply recursively through a file tree. I attempted to use AI to harmonize the rulesets. Some adjustments were made, but the entire set still needs careful review.

✅ Visualize per-package activity within Gutenberg

To better understand per-package activity within the Gutenberg editor project, I produced a visualization showing commit activity.

✅ Provide deep insight into PHP script execution

Inspired by my childhood Gameshark, I built a PHP extension to improve my ability to debug and analyze PHP script runs. This started as a way to compare two runs of a given script, but expanded into a set of related but distinct modes.

Differential mode compares which functions were called and how many times across two different script runs; this could be useful for performance optimizations or comparing what runs for two different code paths and was built initially while working on page renders vs API call responses.

Trace value records every function or method call whose arguments contain a requested value. It tracks user space as well as builtin functions and was built to help identify code paths which send untransformed data where it shouldn’t reach. A follow transformations option tracks not only the given value, but also common escaped, encoded, serialized, quoted, slashed, and other variations of it. This is a clever security tool for finding out where and how unwanted data is passed around.

Invariant mode takes a PHP file with “hooks” that attach to functions and methods, either during entry into those contexts or when returning from them. They are supplied the values to the arguments, the $this value if a method, and the return value if a post hook. This enables a novel approach to applying software contracts on code with neither the production runtime overhead nor the noise from the contract-enforcement. This was loosely inspired by Clojure’s core.spec. Because the hooks file is user-space PHP code with access to global state, this provides mechanisms for enhanced testing and analysis code, and when registering a shutdown handler in PHP, can print reports at the end of script execution. Hooks may also raise exceptions to halt execution when any desired invariant is violated, such as when preg_match() receives a pattern that might be attempting to parse HTML.

Unused runtime coverage mode generates a report of all loaded identifiers which were never read or executed during a script execution. A sampling option can be used in production to assemble such a report, probabilistically, over time. This mode was designed to find effectively dead-code that might be lurking behind runtime conditions which can never actually run due to real data distributions. For example, a function which is only ever called before a given date, when the given date is several years in the past. Static analysis will miss this while a month of production sampling with no calls will provide evidence that it’s safe to remove the function, that no other strange or unexpected call-paths are still calling it.

Trace allocations mode traces heap allocations made by PHP during a script execution. It immediately surfaced unnecessary allocation in wp_is_numeric_array(), which was promptly eliminated in [#12100].

This extension has provided incredible insight into how WordPress and other PHP scripts run, and I’ve only scratched the surface of how I can take advantage of it.

🔄 Introduce dynamic security policies into PHP with eBPF to isolate plugin code and extensions

Like the php-gameshark extension, I built a modified php binary which coordinates with eBPF in the Linux kernel to apply dynamic security policies and create isolated security domains within executing PHP code. There is no logical separation between executing the Core WordPress code and the code from plugins running on a site. This is a security challenge because the two kinds of code warrant different trust, and a site operator may want to assign unique trust and capabilities to different plugins.

This extension provides a wp_runtime_security_apply_policies() function which registers sandboxing rules against files whose source code matches the provided glob. It allows disabling network access, shell execution, sending of emails, reading uploaded files, and writing uploaded files demonstrating a path towards securing WordPress sites from errant or malicious plugins, as well as an explicit opt-in capability model for plugins as they have need. It doesn’t just protect user-space PHP code either; thanks to the fact that policy enforcement occurs within eBPF, it can also apply the same policies against compiled PHP extensions running on the host, assuming that the extensions are not actively attempting to exploit the guards (the protection is aimed at security vulnerabilities within the commonly-deployed PHP extensions, not against potentially-malicious extensions).

I built this extension after a discussion with Lynn Griffith at WordCamp US in late August. It seems promising but is under-developed and needs production testing. As it relies on eBPF, it only supports Linux environments, ruling out Windows, BSD, and macOS-based hosts.

User-space PHP code can change the current policies by passing a descriptor object to the extension showing which file globs are to have which privileges.
Policy rules stack: code deeper in the call stack may further restrict the permissions, but cannot expand them.

✅ Benchmark HTML parsing optimizations against realistic data from the Internet

With the aid of cc-analyzer, I automated the benchmarking of numerous optimizations that we have explored over the years with the HTML API, mostly changes to the internal data structures and how attributes are represented during the parse. The AI tooling provided the run-scripts for cc-analyzer, invoked it, and gathered the results. It also collected PRs that I had proposed (using the github-archiver) since May 2023 so that I didn’t have to find them.

✅ Fuzz-test the HTML API

I fuzz-tested the HTML API, finding several unreported bugs, including easy-to-overlook defects in the code. Fuzzing in this way also prevented a number of defects with the rewrite of wp_kses(). This complements the existing spec-compliance tests against the html5lib test suite, practical tests against real HTML from the web, and a unit-test suite covering intentional behaviors.

❌ Scaffold fuzz-testing in Gutenberg

I attempted to build a generalizable fuzz-testing infrastructure for the Gutenberg editor. This was an extended autonomy agentic session that ultimately produced a good-looking dashboard with nothing but false-alarms. I tried to establish a framework in which other developers could easily add new generative categories and the system would run new fuzzers for them, compare outputs, and triage failures. AI parallelism made for impressive work, but in this early project I was unable to accomplish my goal and gave up on the idea.

✅ Port data sync libraries into PHP

As an experiment in goal-oriented design, ten distributed data structure libraries were ported into PHP userspace code to aid in building a demonstrator for the DE-RTC prototype [#12334, #79602]. With minor caveats, this built working copies of yjs, automerge, loro, diamond-types, diff-match-patch, json-patch, json-joy, sharedb-json0, prosemirror-collab, and collabs which passed their upstream test suites when they were converted to call the PHP code. Eight of the libraries were completed within a few days, but loro (the library I was primarily interested in) and json-joy held out the longest, taking weeks to complete. They appeared stagnant for the bulk of that time and rapidly finished passing the remaining tests in a burst at the end. While I had originally built a prototype collaborative editor with yjs (which is what the existing project team had chosen to use in JavaScript), once automerge completed I was able to swap out the synchronization primitive and later do that again with loro, adding the capability to make more semantically granular changes and merges. This work was almost entirely hands-off and ran in the background until it was completed; every ten minutes it updated an HTML dashboard showing status and operating notes.

✅ Fuzz-test the proposed collaborative editor for WordPress

From the end of April until October, I paired with Dan Luu to fuzz-test the collaborative editor proposal, and we uncovered an array of issues which ultimately led to changes in the timeline for the project, as a number of the defects were nontrivial to solve. Most of the fuzz infrastructure was built by Dan, while I attempted to coordinate the reproducible bug reports with the rest of the team and to propose fixes. The fuzzing machinery produced effectively no false positives due to the triage and reproduction steps built in. It also provided the visuals for theoretical bugs which are hard to diagnose manually with a keyboard and mouse, but which actually occur frequently in concurrent systems.

This was a high-reward project for the investment because, while AI was dominant in the early code generation, once the testing suite was established, it was able to continue to operate without much additional AI input, and it’s possible to run without any AI inputs.

It highlighted two aspects of fuzz-testing: the more robust the code being tested already is, the more valuable the fuzz-testing will be; and the more frequently a bug is likely to materialize, the more quickly fuzz-testing will find it. There is a good match here between the needs and the operating characteristics.

Actually, Dan and I were originally looking at working on other projects for this Radical experiment. I had suggested that we use the nascent collaborative editing project to organize our notes and work within a WordPress site — to “dogfood” the editor. We pivoted to this testing and design support role only because of problems which immediately appeared as we tried to use it.

✅ Prototype a comprehensive collaborative editing environment for WordPress

To demonstrate another approach to collaborative editing, I instructed an agent to follow my core principles and requirements for the task and build a prototype. At first I wanted the agent to mimic forming its own company, planning, dividing labor, and harmonizing productivity, but as this ran for weeks it kept descending into a cycle of producing more and more meaningless paperwork with less and less actual work. Around the end of May I rebooted the project with far more direction and guidance, replacing the goal-oriented and hands-off approach with a human-driving-the-loop method. This proved more effective and in two weeks I had a working prototype that demonstrated every aspect that I considered important and lacking in some of the other public proposals. At some point I will share a version of an internal post I wrote summarizing this work. It proved influential on the project and I believe that the continued development of collaborative editing is heading in a stronger direction as a result.

For years I have struggled to adequately convey why specific principles and requirements are important, but having a visual prototype made it feel real in a way that persuasion had failed me. The amount of up-front work to produce this prototype had been obstructive for years, and without the agent I would not have been able to communicate the tradeoffs involved in its approach.

✅ Restore developer documentation generation by updating deprecated legacy code

At the end of February I had restored WordPress developer documentation which had been stale for two years due to failing build scripts and deploy scripts. While this work resolved most issues and unlocked updated docs for WordPress 6.9, there remained a few unresolved issues which led to specific submodules being excluded from those docs. In mid-May, fixes for the remaining issues were applied to the dependent projects which removed all remaining barriers. All documentation was updatable again and the scripts could run in the latest PHP versions without crashing.

✅ Prevent mistakes in commit messages and automate the repetitive parts of writing them

After seeing my colleague Jon Surrell’s neovim linter for writing WordPress commit messages, I ported his linter into a single-binary/stdout LSP usable in any LSP-supporting editor. This expanded the work Jon did and built upon work from my other tools to show inline previews of Trac tickets and GitHub PRs. It included new auto-fixers for formatting and line ordering and I use this today to prepare my commit messages, avoiding mistakes I have overlooked in the past.

✅ Gather empirical evidence to guide parsing decisions in the HTML API

I used an instrumented custom build of PHP and lexbor in September to answer a perplexing question: “how many tokens of lookahead would be required for the HTML Processor to fully-parse a given percentage of all HTML documents?” This stems from the tricky re-parenting issues in HTML tree building, where a syntax form at the end of the document could appear towards the start of parsed tree structure. The instrumented code examined when lexbor ran its “adoption-agency algorithm” and tracked how much further into the document the current token appeared after the token associated with its actual parent node.

An hour-long run of cc-analyzer showed that among 70,000 documents, approximately 1,000 require at least 1-token lookahead, only about 250 could parse with 5-token lookahead, and 13 would have required more than 10,000-token lookahead! In one case, a document contained an un-closed <b> tag near the start of the document, and then 400 kB and 35,000 syntax tokens later, triggered re-parenting — no default behavior will offer 35,000-token lookahead.

The outcome of this run was disappointing, but the data was invaluable and prevented wasting time implementing a lookahead mechanism that wouldn’t meaningfully benefit consumers of the API.

✅ Review and scrutinize code change proposals

Throughout the entire experiment AI was providing valuable code review and patch preparation. WordPress security fixes are typically backported to WordPress 4.7, which covers 25 released versions and trunk. Many of these support older versions of PHP missing standard-library features that newer code depends on, and lack WordPress functionality that newer code depends on. When preparing a backported patch, I created reports detailing which features and functions had to change at each WordPress release, and what was driving that need. I found these to be more useful than having agents automate the backporting as fewer mistakes were overlooked when I was performing the changes with the assistance of the reports.

AI code review was invaluable though during the refactor of wp_kses() within WordPress. For weeks I instructed it to find the remaining overlooked defects that need resolving before merge, and it kept finding places to harden or fix the code. I never asked an agent to perform “code review” or indicate if a patch was ready to go. Instead, I instructed them to find hidden defects that I wasn’t sure existed, but when told to return three items, they would do it! I consider these kinds of situations among LLMs’ greatest strengths, when false negatives are more costly than false positives, and when validating claims is trivial. Every issue the agent claimed became a test that proved or disproved it and now guards against regression.

Simplenote and Simperium

✅ Implement well-defined feature requests in unfamiliar code

To explore autonomous feature development, I had an agent resolve a concrete bug report describing difficulty copying content from historic revisions of a note [#3358]. This kind of enhancement/fix was frustrating previously because it touches numerous parts of the codebase I was unfamiliar with. The models picked up a number of places I would have overlooked when working on the problem.

✅ Document confusing data flows in unfamiliar projects

The data service powering Simplenote was written with untyped Python code, and partial duck-typed data structures are passed around which can make code comprehension dizzying. While I wanted to avoid AI-generated code changes, given how critical the backend is, in late May I produced comment-only changes annotating data types and providing explanatory comments where certain code constructs were unclear. This was a low-effort way to pass along some insight about the code in hopes that it makes someone else’s job clearer in the future, as I have not maintained this codebase for years.

Random

🤷‍♂️ Monitor Codex usage

codex-usage-report.py scans the ~/.codex directory and summarizes token counts, the models which were used with them, and approximates the dollar cost of that usage based on current API pricing.

✅ Export Codex usage into a searchable format

As the radical experiment was drawing to a close, I created a Codex exporter which dumps the session data into a giant single-file HTML archive where I can search interactively through the sessions and view the chat history, including tool calls, in a rendered view. I’ve referenced this several times as it’s quick and easy compared to logging into a server, finding the right session, and searching through its history.

✅ Run inference on unsupported legacy hardware

My old MacBook Pro came with a dedicated Radeon GPU and sits idle or off most of the time. llama.cpp doesn’t support the older GPU and so I wanted to see if I could get it running. It did produce a working copy that runs local inference on the Radeon GPU, but in practice it underperformed the CPU-based inference for the same models. With only 4 GB of VRAM, it couldn’t load enough weights at one time to operate without constantly transferring data, and the transfer overhead was too high. I explored different means of sharing work between the CPU and GPU, but they were fighting for memory bandwidth.

While this didn’t provide me with a low-and-slow inference engine, it demonstrated the ideas and ran the experiments which is something I had little patience for, given that I expected poor usefulness in the best of cases.

✅ Fix bugs in proprietary hardware drivers

At home I use my Fujifilm X-T3 as a webcam. It makes for a great quality video feed, but when Fujifilm updated the camera driver to integrate with one of the previous macOS updates, they introduced a memory leak which would end up using 90 GB+ of RAM plus swap by the end of a call and sometimes take down my system before I realized it. Knowing I had little hope of motivating Fujifilm to fix this, I made a binary patch to the driver and fixed the bug directly. This was directly inspired by stories of Microsoft fixing bugs in components whose source code they had lost.

To my delight this fixed the memory leak and provided a plausible explanation. By decompiling the driver, the AI found a missing call to release JPEG data from each frame after passing it to CMIOSampleBufferCreate — a classic memory bug. It predicted the impact of this defect and confirmed the rate of memory bloat with successive system dumps of the process. To add the missing release call it shuffled around some existing instructions to a region of padding bytes in the driver and then called into those; this freed up the bytes necessary for the instructions to call the release function. 44 bytes are written across three spans to make the fix, and this is a verifiable fix that I was able to apply without disabling the system integrity protection — an even better delight.

This has been quite possibly my favorite AI-assisted project. There is no way I could have imagined doing this work myself or having traction with Fujifilm to debug and fix this issue, and yet now I can have video calls run on for hours (were I to want such a thing) and memory use by the driver is fixed; it doesn’t fill up and then purge all of my RAM.


A special thanks belongs to Automattic for providing this space in which to learn and explore, to OpenAI who provided elevated access to their frontier models and made it possible to preview what a future of abundant AI might look like, and to the Jetstream2 project funded by US taxpayers who donated high-capacity compute resources to help improve the reliability and security of the WordPress project. I would also like to thank Dan Luu, who worked with me on this project and who taught me so much about practical generative/fuzz testing, and with whom I could never keep pace, in the best of ways.

Over the course of this time period I worked with GPT-5.4 all the way up to GPT-6-Astra, at ultra thinking levels on fast priority, and with Claude Sonnet 4.6–5.4. The earliest use came from Qwen3.5-397B-A17B, but I had also been running Qwen3.5-27B-4bit locally before the experiment started, and by the end was relying on Qwen3.6-27B-4bit.

I’m thankful for the chance to reach into the past and demonstrate ideas I’ve had sitting on the back-burner, as well as to look towards the future and prototype designs I want to see turn into usable products.

Categories
Sports Fox

Sean McVay Has Failed To Push Right Buttons For Rams’ Dream Team; Now It’s Panic Time

SoFi Stadium (Inglewood, California) — Los Angeles Rams running back Kyren Williams compared his team’s latest surprising setback — this one an 18-16 heartbreaker to the Arizona Cardinals — to being stuck in a torrential downpour in sunny Southern California. “You’re either in the storm, coming out of the storm or going into the storm,” Williams said after the Cardinals stormed SoFi Stadium following Chad Ryland’s game-winning field goal at the buzzer. “Right now, we’re in the middle of a storm. It’s raining. It’s not shining at all. That’s why we’ve got to continue to keep working.” Yes, it does occasionally rain in Southern California, and the Rams haven’t been able to dodge puddle-sized raindrops since the team’s disastrous, misguided trip to Australia to start the year. The heavy favorite to start the year, earning the “Dream Team” moniker because of blockbuster offseason trades for Myles Garrett and Trent McDuffie (who both did not play on Sunday due to injury), the Rams have embarrassingly stumbled out of the gate to a 2-4 record. And the Rams have now joined a list no team with title aspirations wants to be on. Los Angeles is the fifth outright preseason Super Bowl favorite with a losing record through six games in the past 50 seasons, joining the 2015 Seahawks, 2002 Rams, 1999 Vikings and 1987 Giants, per FOX Sports Research. None of those four previous teams reached a conference championship game, and, of course, the Rams will try not to join them. But for that to happen, the team will have to go through some extensive soul-searching as they prepare to face the Las Vegas Raiders on the road next week. Rams head coach Sean McVay understood this would be one of the toughest coaching jobs of his career. He’s been adept at leading teams with big personalities in years past, including a Super Bowl winning team that included Von Miller, Odell Beckham Jr., Jalen Ramsey and Eric Weddle. Like those teams, McVay has had to manage big personalities like Puka Nacua, Davante Adams, Myles Garrett and Aaron Donald this season. But this year, McVay has struggled to put it all together and get those boisterous personalities to play with passion and to their full potential. And McVay knows it, too. “I have to do a better job and figure out how exactly we settle guys down,” Rams head coach Sean McVay said following Sunday’s loss. “But we’ve had some really critical errors at some really unfortunate times. That’s what our narrative has been this year. And we can’t keep saying that we haven’t done that before, because this year we are doing it. “We have to be able to fix it. And it’s my job to do that.” This part of the schedule was supposed to be the easy stretch for Los Angeles. After a tough five weeks to open the year, Weeks 6-10 consisted of facing the Cardinals twice to go along with the games against the Raiders, Los Angeles Chargers and Washington Commanders. But as it stands, with the Rams stubbing their toe on offense with pre-snap penalties, uncharacteristic, unforced errors and turnovers, they’ll be lucky to beat any of those teams. “It’s definitely a reality check,” running back Blake Corum said. “But we know that we’re good. We know we have the guys. We know we have the culture. We know we have the team. But, like Coach [McVay] said, it’s time to get back to work. We have to watch this film and see where things aren’t aligning and then fix those things.” The problem is, this team, considered the best in the NFL, is struggling to compete against the bad teams. The Cardinals are playing for draft position and the right to land a franchise quarterback next April. Their only other win this season is against the other team from L.A.: the Chargers, who are one of only two remaining winless teams after Sunday’s games. New Arizona head coach Mike LaFleur now has more wins at SoFi Stadium (2-0) this season than both teams in Los Angeles (the Rams and Chargers have a combined one win at SoFi Stadium this season). But he and the Cardinals have struggled outside of Southern California. They entered Sunday’s contest with the worst-ranked scoring defense in the league, but held the Rams to 286 total yards and 16 points as Los Angeles also failed to convert on both of its fourth-down tries. “We have to go out there and grind and we’ve got to stop hurting ourselves,” center Coleman Shelton told me. “You can’t go out there and play against two teams every time we play a game. We can’t play against them and against ourselves. We’ve got to be a team, go to work and do our best to put ourselves in the right position.” “I think it’s a whole host of things,” tight end Colby Parkinson told me when I asked about the unforced errors. “Lack of focus is definitely at the top. But we have to be more clued in, play in and play out, just focusing on the one play. I think as a whole we can all do better at that.” Special teams were once again an issue for Los Angeles. New kicker Blake Grupe made a 44-yard field goal to start the game, but on the ensuing kickoff, the Rams gave up another big return and Grupe had to make the tackle, injuring his knee. Grupe’s leg was in a brace in the locker room afterward, and Los Angeles had to use punter Ethan Evans for field goals and kicks. Backup quarterback Stetson Bennett served as the holder. Because of the injury, McVay went for a two-point conversion after Corum’s 15-yard touchdown catch in the first half, which led to Matthew Stafford absorbing a vicious, blindsided hit by Arizona edge rusher Josh Sweat that caused a fumble. Speaking of Stafford, he finished 25 of 32 for 222 yards, two touchdowns and no interceptions. Lead running back Kyren Williams, meanwhile, only had 10 carries for 50 yards. Williams did play 71.4% of the offensive snaps, though, but he still suggested he would’ve liked to have been more involved in the offense. Asked why his team’s offensive energy was inconsistent, Williams bluntly said: “I can’t tell you. Probably because I’m not out there.” Williams’ comment and apparent swipe at his coach quickly gained traction on social media following Sunday’s game, but he’s still bought into turning things around. McVay and the Rams can take solace in the fact that they’ve been here before as well. They started 1-4 in 2024 and finished 10-7, making the playoffs. The year before that, they started 3-6 and finished 10-7, reaching the postseason after going 5-12 in 2022. “You use this adversity for moments in the future that’s going to allow us to be who we want to be,” Williams said. “You go through things in life so that it helps you grow. When you’re uncomfortable, that’s where real growth occurs. So, right now, obviously we’re uncomfortable with where we’re at in the standings and losing these games. “But that’s where we really have to dig down deep, have the faith that we know that we have and continue to work. The work works. And believing in the work.”​Latest Sports News from FOX Sports

Categories
Sports Fox

Overreaction Monday: Rams Will Miss The Playoffs? Are The Cowboys Cooked?

Week 6 brought many of the things we’ve grown accustomed to in the young 2026 season. However, Sunday might have given us the biggest surprise far this year. The Arizona Cardinals pulled off the biggest upset of the season with their 18-16 victory over the Los Angeles Rams. Arizona entered Sunday’s game as a 12.5-point underdog, but was in control for much of the day as it picked up its second win at SoFi Stadium. As great a story as the victory was for the Cardinals, though, much of the focus will turn to the Rams. Can they dig themselves out of this 2-4 hole, or are they already too far behind? Are the Dallas Cowboys and Philadelphia Eagles set to join the Rams in the land of disappointments as well? Let’s overreact to Sunday’s Week 6 action. After a bad overtime loss to the Buffalo Bills on Monday, the Los Angeles Rams looked even worse in an 18-16 loss to one of the worst teams in the league, the Arizona Cardinals, on Sunday. Special teams was the culprit once again, as the Rams gave up another big kick return. And to make matters worse, new kicker Blake Grupe suffered a knee injury while attempting to make a tackle on the play and was done for the day. Grupe did make a 44-yard field goal before the injury, though. But because of the injury, the Rams attempted a two-point conversion after a touchdown reception by Blake Corum in the first half, which led to quarterback Matthew Stafford taking a vicious blindside hit on the play by Arizona edge rusher Josh Sweat. The conversion was no good as a result, keeping the Rams’ streak of failing to convert a two-point conversion since 2023 alive. However, it wasn’t just the special teams that failed the Rams on Sunday, as the hit Stafford took on the two-point try might have been a microcosm of their day. The Rams turned the ball over at inopportune moments, had head-scratching pre-snap penalties and a defense that still misses injured superstar and reigning Defensive Player of the Year Myles Garrett. Conclusion: Overreaction … for now You can blame Los Angeles’ struggles on special teams gaffes, but the reality is the Rams do not look like the dangerous, dominant Super Team we expected to see at the start of the year. Facing an Arizona squad led by former Rams offensive coordinator Mike LaFleur, the Cardinals didn’t look intimidated or in awe of the Rams. Even though Sean McVay has had good success against the Cardinals over the years, the Rams struggled to move the ball against a bad Cardinals defense and allowed an offense led by Jacoby Brissett to go up and down the field for six scoring drives. Los Angeles does have a schedule easy enough for it to get wins in the coming weeks, which could allow it to control its own playoff destiny later in the regular season. But after losing games like they did on Sunday, not every win seems guaranteed for the Rams. McVay told his players they have to get back to work to solve their issues, and he’s correct. And while it’s still early, at 2-4, the games are starting to slip away. The Cowboys have been doing their best to support new defensive coordinator Christian Parker as he attempts to make the unit a more competitive, connected group. The latest change was hiring former long-time defensive coordinator Mike Pettine, who worked with Parker in Green Bay, as senior defensive assistant. Joey Porter Jr., who the Cowboys acquired in a trade earlier this month, helped buoy the secondary with his sticky coverage on the perimeter. The Cowboys also made changes to their starting lineup, as edge rusher Malachi Lawrence replaced Donovan Ezeiruaku, Markquese Bell moved to safety and rookie Caleb Downs played nickel defender. But none of the changes created a significant improvement for the Dallas defense, as the Green Bay Packers raced out to a 17-0 halftime lead and held on for a 23-13 victory that wasn’t as close the score suggested. Conclusion: Not an overreaction Despite major changes to the coaching staff and personnel, the Cowboys still are ineffective on defense. And that’s unfortunate, considering Dallas has one of the most explosive offenses in the league, led by Dak Prescott, CeeDee Lamb and George Pickens. However, even the offense didn’t show up for a second straight week following a lackluster showing against the Tampa Bay Buccaneers, putting up 303 total yards on Sunday. Add to that, the Cowboys play in one of the most winnable divisions in the NFL in the NFC East, and they could be competitive if they can just get average production from the defense. Despite the changes, that doesn’t appear to be happening, meaning the pressure will continue to intensify for head coach Brian Schottenheimer to fix the issue — or owner Jerry Jones will have to find a new head coach to fix it at the end of the year. Chicago Bears head coach Ben Johnson’s offense looked dangerous again with Caleb Williams back under center after he suffered a hamstring injury that sidelined him for three games. Williams sizzled, completing 30 of 36 passes (83%) for 305 yards and a touchdown. The Bears scored the most points this season since dropping 59 points in a season-opening win over the Carolina Panthers, hanging on to defeat the Atlanta Falcons 31-23. Williams was perfect from a clean pocket, completing all 24 passes for 248 yards, the most attempts without an incompletion from a clean pocket since 2018, according to Next Gen Stats. Conclusion: Not an overreaction Chicago is one of the most dangerous offenses in the league with Williams back, and that was apparent from the jump. The third-year quarterback completed his first 12 passes on Sunday, giving him a new career high for consecutive completions thrown to start a game. That helped Chicago get out to a quick 14-0 lead, as it also showed its balance on offense due to its ability to run the football with D’Andre Swift and Kyle Monangai when he’s healthy. Along with that, defensive coordinator Dennis Allen leads an improved defense that held an Atlanta offense that’s been explosive as of late to 257 total yards and sacked Michael Penix Jr. five times. A good portion of those yards came after the Bears took a 31-7 lead, keeping the Falcons at bay for most of the day. While the Bears play in the most competitive division in football in the NFC North, Chicago could be the most balanced of the four. That should mean it’s capable of making a deep postseason run, led by the arm and legs of Williams. Subbing for an ailing Jalen Hurts (out indefinitely with blood clots), backup quarterback Tanner McKee had trouble moving the Philadelphia Eagles’ offense on Sunday. The Eagles managed just 14 points and had six negative plays at home in a 25-14 loss to the Carolina Panthers. McKee finished 25 of 46 for 217 yards, with a touchdown pass and no interceptions. He was sacked three times, posting a 77.5 passer rating. McKee’s longest pass completion was 19 yards, so the Eagles once again created very few explosive plays in the passing game. And Sunday’s loss marked their fourth in a row as they prepare to play without Hurts for at least three more games due to his injured reserve placement. Conclusion: Not an overreaction Even with the Eagles’ struggles, they still play in a winnable division, which my colleague Ralph Vacchiano aptly labeled the NFC Least last week. So, why not make a move to improve quarterback play and give a talented defense to compete and win the division? We’ve got a name in mind, too. Even after their upset win on Sunday, the Cardinals should be playing for draft position under first-year coach Mike LaFleur. A quarterback like Cardinals veteran Jacoby Brissett could be the stabilizing and steadying force that the Eagles need, and one they should consider. After Sunday’s win, Brissett has thrown for 1,328 yards, nine touchdowns and six interceptions this season, ranking in the middle of the pack among quarterbacks in most notable stats. Eagles general manager Howie Roseman has been willing to take big swings in the past, including signing Saquon Barkley and trading for A.J. Brown. Making a move for a quarterback like Brissett does not compare to those blockbuster deals, but it also shows the locker room that the Eagles have not given up on this season. In his second NFL season, Hunter is finally emerging as a consistent playmaker for the Jaguars. Hunter played nine snaps on offense, 58 plays on defense and two on special teams in the team’s buzzer-beater loss to the Houston Texans on Sunday, making standout plays on both sides of the ball. Offensively, Hunter finished with four receptions for 59 receiving yards on four targets, including a 7-yard catch out of the backfield for a score. He now has two career touchdowns, and, coincidentally, they’ve both happened at Wembley Stadium. Hunter’s first touchdown grab came a year ago in the Jaguars’ blowout loss to the Rams. Defensively, Hunter had three combined tackles and an interception of a C.J. Stroud pass intended for Xavier Hutchinson that he undercut in the end zone. That interception was pretty clutch, too. Jacksonville needed to keep Houston off the board in order to prevent the Texans from extending their 31-28 lead at the time. Conclusion: Overreaction Hunter became the first player to catch a touchdown pass and notch an interception in a game since Brian Dawkins in 2002, joining rarified air on Sunday. Even though it happened in a losing effort to the Texans, Hunter made the type of impact plays that the Jaguars believe justified their reasoning for giving up significant draft capital to move up in the draft to take the Colorado product with the second overall pick last year. However, after playing just seven games in his rookie year due to a season-ending knee injury, Hunter still has to show more. Last season, Hunter played mostly on offense, totaling 28 catches for 298 receiving yards and a score. He played in 156 defensive snaps, totaling 15 combined tackles and three pass breakups, leaving most people underwhelmed with his play. This year, the Jaguars have used Hunter as an every-down cornerback who plays as a part-time receiver. Prior to Sunday, Hunter had played in 79% of the Jaguars’ defensive snaps and just 7% of their offensive snaps, finding some success in utilizing him that way. Still, Hunter needs to prove he can maintain the high level of play while staying on the field for the duration of an NFL season before we make any big claims about his stardom.​Latest Sports News from FOX Sports

Categories
Alaska News

Juneau hazmat team intercepts suspicious envelope addressed to state Division of Elections

A suspicious envelope addressed to the Alaska Division of Elections in Juneau was intercepted by a hazardous materials response team and turned over to the FBI on Saturday, in what is believed to be part of a large number of mailings to congressional and election officials nationwide, according to Capital City Fire/Rescue Chief Tom Hatley.

The FBI notified CCFR on Friday the envelope was expected to arrive in Juneau on Saturday, and at about 9 a.m. Saturday the fire department was notified by U.S. Postal Service officials at the downtown Juneau facility it had arrived, Hatley said in an interview. CCFR Hazardous Materials Team responded and retrieved the envelope.

“At this time, the contents of the envelope have not been confirmed. Our response is being conducted out of an abundance of caution,” CCFR stated in a post on its Facebook page at 12:30 p.m. Saturday.

Juneau Police Department officials blocked the street outside the delivery entrance to the postal facility at the federal building on Glacier Avenue during the hazmat team’s response.

The Associated Press on Friday reported federal officials are investigating letters with suspicious substances mailed to congressional and election offices nationwide and are urging recipients to treat the mailings as “potentially hazardous.”

“Some of the letters contained an unknown substance and we are working closely with our law enforcement partners to respond to each incident,” a statement by the FBI notes. “We are also working with our partners to identify the individual or individuals responsible for the letters.”

A similar threat occurred in 2023 when election offices in six states received mailings that contained a white powder, according to the Associated Press. Another series of mailings, including to Alaska, occurred in 2024.

Saturday morning’s response by CCFR occurred shortly before and a few blocks away from a “No Kings” protest whose organizers were urging people to vote early in the Nov. 3 midterm elections due to concerns that include questions about handling of mailed ballots. Early voting in Alaska begins Monday.

This story was originally published by the Juneau Independent.

The post Juneau hazmat team intercepts suspicious envelope addressed to state Division of Elections appeared first on Chilkat Valley News.

Categories
Sports Fox

NFL Week 6 Defining Stats: Mahomes Matches Brady, Travis Hunter Makes History

Week 6 brought another round of records, led by historic milestones and teams heading in very different directions. Patrick Mahomes matched Tom Brady with another milestone win, while Travis Hunter made history on both sides of the ball. Puka Nacua and Alvin Kamara joined elite company, Kenneth Walker III continued his remarkable start with the Chiefs, and Caleb Williams and Drake Maye continued to show why they’re among the NFL’s best quarterbacks. Elsewhere, J.J. McCarthy finally had his moment with his new team, while the Eagles and Rams found themselves on the wrong side of history. From record-setting performances to struggles that defy expectations, here are the numbers that defined Week 6: This page may contain affiliate links to legal sports betting partners. If you sign up or place a wager, FOX Sports may be compensated. Read more about Sports Betting on FOX Sports.​Latest Sports News from FOX Sports

Categories
Sports Fox

Stay Hot, Wisconsin: 3 Takeaways As Packers Continue Win Streak In Victory vs. Cowboys

Remember when the world was crashing down on the Green Bay Packers? When their offensive line was a disaster? When we’d already started thinking about writing the eulogy on their season? Well, now they’re one of the hottest teams in the NFL. Green Bay took down the Dallas Cowboys 23-13 at Lambeau Field on Sunday night, its third straight victory — tied for the second-longest active winning streak in the NFL. The Packers (4-2) scored 17 points in the first half, blanking the Cowboys in the first 30 minutes to go with two takeaways. And for the Cowboys (2-4), they’ve now lost three of their last four games. Concern continues to mount in Dallas after scoring just 13 points, one week after losing to the previously winless Tampa Bay Buccaneers. Here are my takeaways from Sunday’s game: Dak Prescott and the Cowboys’ passing attack struggled Sunday night, but we’ve seen it: Prescott and wide receivers CeeDee Lamb and George Pickens can catch fire in the blink of an eye. Dallas’ run game, though, remains an Achilles heel for Brian Schottenheimer’s offense. It produced just 48 yards on 15 carries (3.2 yards per rush) in Week 6 — the fifth time in six games that the Cowboys have had 75 or fewer rushing yards. With the Packers doing such a great job covering the back end, Dallas had nothing it could lean on offensively. It makes life much more difficult for Prescott, who had one of his worst games of the season (34 of 54, 258 yards, TD, 2 INTs). So this is at the crux of the Cowboys’ problems: Dallas’ offense can’t be consistently effective enough to bail out its defense, which continues to struggle. The Packers went 11 of 18 on third down, including seven straight conversions on third down to start the game. It was a lot worse for defensive coordinator Christian Parker’s unit than the final score suggests, but missed opportunities by receivers Christian Watson and Matthew Golden helped (more on this below). When Jordan Love drops back and the Packers’ O-line gives him time to throw, there’s arguably no scarier sight to NFL defenses right now. Between Love’s superb deep ball and WR1-caliber production from both Christian Watson and Matthew Golden, the Packers can be borderline unstoppable in the passing game — even if it didn’t always look that way Sunday night, when Golden dropped two would-be touchdowns and Watson couldn’t secure a pass that touched his hands in the end zone. The threat is there. But Green Bay’s run game has been a persistent issue, and it showed up again Sunday night, when the Packers had just 57 rushing yards and couldn’t dominate the time-of-possession battle. And the Cowboys entered this week with the league’s worst run defense. So what happens when the passing game is off for the Packers against better defenses? When they have to prove that they can move the chains and get chunk yards on the ground? Green Bay, which has climbed back into NFC contention after a rough start to the year, is not a championship-caliber team as long as it’s one-dimensional offensively. In back-to-back weeks, the Packers have lost standout linebacker Edgerrin Cooper and veteran defensive tackle Javon Hargrave to season-ending Achilles injuries. That’s on top of the continued absence of All-Pro edge rusher Micah Parsons (ACL), who’s yet to practice and remains on the physically unable to perform list. So Green Bay has been shorted defensively, but that hasn’t seemed to matter. A week after registering its first five-takeaway game in a decade, the Packers’ defense stymied the Cowboys’ explosive offense. Dallas didn’t score until nearly halfway through the third quarter, and its second touchdown practically came in garbage time. In the first half, Green Bay picked off Dak Prescott twice — the Cowboys quarterback had just three interceptions through the first five games — and held Dallas scoreless. Veteran safety Evan Williams, who had one of the picks, has been playing at an All-Pro level. The Packers have been an effective blitzing team and strong on early downs. Entering this week, they were allowing the third-fewest yards per play (4.3) and third-lowest success rate (38.2%) on first and second downs, according to Next Gen Stats. That can position Parsons to thrive on passing downs when he returns, elevating Green Bay in a huge way in the process. The Cowboys are back in primetime next week, as they’ll travel to Philadelphia to face the division-rival Eagles on Monday Night Football. The Packers will be on the road to face the Detroit Lions in America’s Game of the Week next Sunday (4:25 p.m. ET on FOX, FOX One and the FOX Sports app).​Latest Sports News from FOX Sports

Categories
Sports Fox

NFL Fallout Week 6: The Giants Should Start QB J.J. McCarthy; The Bears Are Back

The New York Giants are not a very good football team. Their 34-27 home loss to the New Orleans Saints on Sunday exposed all of their flaws. They are lucky to be 3-2-1 and in first place in a terrible division. And if they want to stay there and make a real run at the playoffs, they have to give J.J. McCarthy their starting quarterback job. McCarthy, the 23-year-old former Vikings bust, replaced Jameis Winston on Sunday with New York in a 34-10 hole and 11:25 left in the game. Then all he did from there was very nearly pull off a Meadowlands miracle. He led three fourth-quarter scoring drives, threw for 243 yards and a touchdown, and almost hit tight end Isaiah Likely with a game-tying touchdown pass with six seconds left in the game. “I thought he came in there and did a heck of a job given the circumstances,” Giants coach John Harbaugh said. “(It was) kind of desperation time. It’s different than normal football. But (he) made some plays and got us back, gives us a chance to win the game. And we’re throwing the ball in the end zone at the end, so that was good. You’ve got to compliment him on that.” He didn’t complete that last pass into the end zone — the ball went through the well-covered Likely’s arms — and McCarthy’s overall performance was far from perfect. He completed only 11 of 21 passes and his first drive ended with an interception. But he gave life to a Giants offense that had stalled and struggled over the previous three-plus weeks with Winston despite not losing a game. And really, the Giants knew this day would come when they traded a fifth-round pick to Minnesota for McCarthy just a week after losing starting quarterback Jaxson Dart for the season. They knew that McCarthy was going to play at some point. And even though Harbaugh refused to commit to McCarthy as his starter for Week 7 in Houston, he has to know that’s the only logical choice. And by the time he looks at the film, that will be obvious. Forget all the excuses about “desperation time” and the Saints’ soft and terrible defense. This is about what McCarthy did in that situation. He completed big passes (five for at least 20 yards and two for more than 45 yards). He stayed out of trouble (after getting picked on his fourth pass). And McCarthy did it all under duress, with both of the Giants’ starting tackles sidelined and the pocket crumbling in front of him most of the time. He did what New York’s brass liked about him when they traded for him back in September — at a time when I wrote Winston was the best of the Giants’ terrible options to replace Dart. McCarthy reminded them of Dart. He moved around the pocket. He spun out of trouble and extended plays. And when the Giants got the ball back with just 57 seconds remaining and 71 yards to go, he kickstarted a potential game-tying drive by stepping away from the pass rush and taking off for a career-long 28-yard run. Winston, at age 32, has neither that kind of mobility nor playmaking ability. And while he’s got a bigger arm, he’s been the high-wire act everyone figured he’d be since Dart went down, completing just 57% of his passes with seven touchdowns and five interceptions in five games. Maybe McCarthy will prove to be risky, too. But at the very least, it’s worth exploring whether he can manifest the upside he showed upon being the No. 10 overall pick of the 2024 draft. He’s earned the chance to prove that Sunday’s performance wasn’t a fluke. Besides, it would be a terrible message if, after watching McCarthy’s near miracle, Harbaugh turned back to the quarterback who got him into the original mess. There’s too much at stake for that. The NFC East is a total mess. The door is wide open. And the Giants already have a lead. What they need are players who propel them forward, not ones who hold them back. The former is what McCarthy did on Sunday. He gave the Giants’ offense a bolt of energy they haven’t had since Week 1. And they’re going to need more of that because it’s going to be a fight for this flawed team every step of the way. They will need everything that McCarthy gave in those magical 11-plus minutes if they’re going to make a real run at the playoffs. They need to give McCarthy a shot to see if he can do it again. It’s been 34 years since the 1992 San Diego Chargers became the only team in NFL history to start a season 0-4 and reach the playoffs. But the Texans are going to join that exclusive club. Yes, it was just a few weeks ago that many of us pronounced them dead. But this isn’t just an overreaction to a two-game winning streak and their 34-31 win over the Jaguars in London on Sunday. It’s an acknowledgment that they may have solved their biggest problem: QB C.J. Stroud. He was outstanding on Sunday against a strong Jaguars defense, completing 24 of 34 passes for 312 yards and three touchdowns. In fact, over the past three weeks, he’s started to look like he did as a rookie in 2023 — a version the Texans have been waiting for three years to see. Over these three games, Stroud has averaged 313 passing yards. He’s got five touchdown passes in the past two games, too. But most impressive is how comfortable he looked against a blitz-heavy Jacksonville defense. He has been bludgeoned behind bad offensive lines in his career. (He’d been sacked 14 times through the first five games this season.) But he stood strong in the pocket on Sunday and just kept firing away. In the end, he was an impressive 10 of 11 for 118 yards and two touchdowns under pressure, according to NextGen stats. And for the first time this season, he wasn’t sacked once. Yes, he threw a costly interception on a lazy pass into the end zone which could’ve given the Texans a 10-point lead with 3:53 remaining. But it was also his first interception of the season, after a franchise-record 216 straight clean passes. And that was very reminiscent of 2023 when he set an NFL record with 191 straight passes without an interception to start his career. Stroud has weapons now, too, after the Texans took a flier on former first-round pick Marvin Harrison Jr. (3 catches, 34 yards), who joins go-to target Nico Collins (3-74) and impressive second-year receiver Jaylin Noel (4-107-1). In fact, Stroud had four completions of at least 20 yards on Sunday. That gives him 25 on the season — most in the NFL. Now, Stroud might not be able to solve all of Houston’s problems. The Texans’ running game was bad even before running back David Montgomery got hurt. And DeMeco Ryans’ defense sure isn’t what it used to be. The Texans have given up 399 or more yards in three of their six games — including 412 to the Jaguars. It’s a mark opponents had reached just once in the previous 38 games. But Houston’s upcoming schedule is weak, Stroud is playing strong, and that could be enough to get this team back into contention. And that is remarkable, because just two weeks ago, the Texans didn’t have much hope at all. It was never going to be enough for QB Caleb Williams to just return to the field. He was going to have to look like his same old magical self to really give the Chicago Bears the jolt they needed. And that’s what he gave them on his first drive Sunday against the Falcons when he escaped a collapsing pocket, rolled to his right, contorted his body and zipped a pass through two defenders to tight end Colston Loveland for the first touchdown of the game. Plays like that are what keeps defenses on their heels and will keep the Bears (4-2) in Super Bowl contention all season long, as long as Williams really is fully recovered from the hamstring injury that kept him out the past three games. He looked pretty healthy in the Bears’ 31-23 win in Atlanta, completing 30 of 36 passes for 305 yards and a touchdown in what was a 31-7 rout with 10 minutes to go. Notably, Williams didn’t run the ball at all — he had just three carries for 2 yards before taking a knee on the last snap. That’s hardly unprecedented for him, but a big change from the 15 carries for 107 yards and two touchdowns he had in the first two games. Whether that was intentional or not, he used his legs enough to give Ben Johnson’s offense the explosiveness it lacked with Tyson Bagent and Case Keenum. Even without Williams, these Bears are probably a good team. But they have a chance to be a great team if they can keep him on the field. So, how long exactly is jet lag supposed to last? Because the Rams’ dumb idea to fly 15 hours to Melbourne and play their opening game 24 hours later was a convenient and easy excuse for their slow start to the season. But at this point, it’s Week 6 and their entire season has turned into an awful slog. It’s almost hard to believe that a team this talented could struggle as much as they have, or capable of gaining just 286 yards in a stunning 18-16 home loss to the Arizona Cardinals. That’s the 2-4 Cardinals, by the way, who now hold a tiebreaker over the last-place Rams (2-4) in the NFC West: an unfathomable truth even after L.A.’s  Week 1 disaster. But what we all failed to take into account is that the Rams are an old team, with an average age of 27 — one of the oldest in the league, in fact. They are capable of greatness in short bursts, such as their late-game comeback in Philadelphia two weeks ago, their fourth-quarter rally against the Bills last Sunday, and even on their final touchdown drive against the Cardinals. But sustaining the greatness everyone expected all season against a brutal schedule and an unprecedented travel itinerary was probably always going to take its toll. The Rams always thought they’d have a chance to get things right when they hit the soft spot in their schedule. But that five-week stretch just began with an unthinkable loss this weekend. That’s not to say the Rams are done. Probably far from it. But it’s probably time everyone considerably lowered their expectations. Because old and tired doesn’t usually improve over time. And these Rams have to face the Seahawks (twice), the 49ers and the Chiefs in December and January. If they don’t get back in the race soon, there’s just no way they’ll survive that. The Philadelphia Eagles are going to get a good look at life without Jalen Hurts over the next four weeks, at least. It should be enough to scare them into preparing for life without Hurts in a few years. Not that they didn’t have enough offensive problems before Hurts got hurt, but it sure isn’t going to get any better under backup Tanner McKee. He’s a fine backup, but he needed 45 passes to throw for 215 yards on Sunday in an ugly 25-14 loss at home to the Carolina Panthers that dropped Philly to 2-4 on the season. With its injury-riddled offense in shambles, McKee’s just not good enough to get much done. Now don’t misunderstand this: Hurts’ time in Philadelphia is far from over, even with him out indefinitely because of a blood clot in his calf. He’s only 28. He’s under contract for two more seasons. And the Eagles couldn’t even think of getting rid of him until after the 2027 season given the cap ramifications. But now is the time to start planning for that possibility, because the hardest thing to do in pro sports is to transition from one successful franchise quarterback to another. Most teams, aside from the Green Bay Packers, only excel in finding ways to screw that up. That’s why GM Howie Roseman needs, more than ever, to take advantage of this opportunity, to sell off some players so he has ammunition in the next draft. Then he can select Hurts’ eventually successor, like the Packers did with Jordan Love when Aaron Rodgers was still their quarterback, and like they did with Rodgers when Brett Favre was still there. Roseman did that once as well, of course, using a second-round pick on Hurts in the 2020 draft when Philly still had then-27-year-old Carson Wentz. The Eagles were still Wentz’s team back then. But they made sure they were ready for when they weren’t anymore. Now they need to do it again.​Latest Sports News from FOX Sports