Daily Reading for 2026-10-13

AI Agents and Agentic Engineering

Both pieces argue the hard part of agentic AI is no longer the model but the engineering discipline around it. SRA’s security deployments succeed only after teams map workflows into narrow, well-bounded tasks; the agent automates the task, not the vague ambition. Huntley’s agentic-engineering essay makes the same point from software: loops, filesystem-as-state and harnesses matter more than hand-typed code, and skills/AGENTS.md files are “astrology” compared with deterministic hooks and verification. Together they frame agents as a capability that rewards preparation, scoping and back-pressure over model worship, and they ask what moat, career and process survive once code and triage become cheap.

Watch for:

• Whether “map the workflow before you build the agent” becomes a standard, billable service line rather than an ad-hoc workshop.
• Agent harness patterns (filesystem-as-state, Ralph loops, pre-commit gates) consolidating into commodity frameworks.
• Signs that verification and back-pressure, not model upgrades, become the real differentiator.

Wardley signals:

• Components: AI agents (SCALR AI, Codex, Claude Code); workflow-mapping workshops; agent harnesses and loops (Ralph, filesystem-as-state); skill packs and AGENTS.md; pre-commit verification hooks; security alert triage; Entra application key rotation.

• Evolution stage: AI agents — Custom (rapid learning, competing forms, no accepted practice); agent harnesses — Genesis/Custom (novel, unstable); skill packs/AGENTS.md — Genesis (disputed, “astrology”); security alert triage automation — Product (growing market, feature comparison); Entra key-rotation automation — Custom/Product.

• Doctrine hits/misses: hits — “Know your users” and “Focus on user needs” (map workflows), “Use appropriate tools”, “Bias towards action” (Huntley), “Think small teams”; misses — “Remove bias and duplication” (skill-pack churn duplicates instructions) and “Manage inertia” (teams too busy to map the work).

• Climatic patterns: “Everything evolves through supply and demand competition”; “Higher order systems create new sources of value”; “Efficiency enables innovation (Componentisation effect)”; “Success breeds inertia” (IDEs, typing code by hand).

• Diffusion markers: agentic-engineering practice crossing from early adopters into the mainstream (Huntley’s January inflection); vendor AI workshops and free tiers signalling market formation; copy-cat agent tooling and “infinite software” rebuild services.

• The Prep Work to Make Agents Effective

• nobody should type code by hand anymore. here’s what’s left.

wardley-beta
%% 1. Users: security operations leads and software engineers adopting agents
%% 2. Needs: deploy agents that reliably do narrow, well-scoped work
%% 3. Capabilities: workflow mapping, agent harnesses, and verification/back-pressure
%% 4. Components: workflowMapping, skillPacks, agentHarness, verificationGates, securityAgent, codingAgent
%% 5. Maturity: workflow mapping and skill packs are Genesis; harnesses and gates Custom; agents moving to Product
%% 6. Management: security teams (SCALR AI) and engineers running Codex/Claude Code
anchor securityOpsLead [0.92, 0.9]
anchor softwareEngineer [0.9, 0.85]
component skillPacks [0.12, 0.35]
component workflowMapping [0.15, 0.55]
component agentHarness [0.28, 0.5]
component verificationGates [0.33, 0.58]
component securityAgent [0.42, 0.72]
component codingAgent [0.55, 0.8]
skillPacks -> agentHarness
workflowMapping -> securityAgent
verificationGates -> securityAgent
verificationGates -> codingAgent
agentHarness -> codingAgent
securityAgent -> securityOpsLead
codingAgent -> softwareEngineer
evolve workflowMapping 0.3

Simon Willison’s Tools

Two small, personal developer utilities show how quickly tooling now gets built and how it plugs into an existing ecosystem. web-edit is a phone-friendly Python web app for browsing and editing files in a folder, deliberately run over Tailscale so credentials never round-trip through the LLM that helped build it; it uses CodeMirror 6 because Monaco’s mobile story lags. datasette-ports 0.4 is an incremental Datasette plugin update that now reports each instance’s PID, making it trivial to attach the new Python 3.15 profiler. Together they illustrate the agent-assisted, single-maintainer workflow: tiny apps, honest scope, and tight integration with Datasette and Python’s evolving standard library.

Watch for:

• Whether phone-first, Tailscale-scoped admin UIs become a common pattern for agent-built tools.
• Datasette’s plugin ecosystem continuing to absorb operational niceties such as PIDs and profiling hooks.
• CodeMirror versus Monaco for mobile code editing as agent-generated apps proliferate.

Wardley signals:

• Components: web-edit; CodeMirror 6; Monaco; Tailscale; Codex/GPT-6 Astra; Datasette; datasette-ports; Python 3.15 sampling profiler; the Datasette plugin ecosystem.

• Evolution stage: Datasette — Product (mature, plugin ecosystem, feature comparison); Datasette plugins — Product (standardised extension mechanism); Tailscale — Commodity/Product (utility networking); CodeMirror — Product (widely used component); web-edit — Genesis (0.1a0, novel personal tool); Codex-assisted app generation — Custom (emerging, competing forms).

• Doctrine hits/misses: hits — “Think small teams” (single maintainer), “Use appropriate tools” (CodeMirror over Monaco for mobile), “Focus on the outcome” (edit credentials without exposing them), “A bias towards open” (open-source plugin); none clearly violated.

• Climatic patterns: “Higher order systems create new sources of value” (plugins atop Datasette); “Components can co-evolve (practice with activity)”; “Efficiency enables innovation (Componentisation effect)” (agents lower build cost).

• Diffusion markers: agent-built personal tools proliferating; a plugin ecosystem extending a platform; Tailscale as default personal networking; reuse of the stdlib profiler across tools.

• web-edit 0.1a0

• datasette-ports 0.4

wardley-beta
%% 1. Users: a developer editing files from a phone
%% 2. Needs: browse and edit files without routing credentials through an LLM
%% 3. Capabilities: a mobile web editor, secure private networking, and ecosystem plugins
%% 4. Components: webEdit, codeMirror, tailscaleNetwork, datasettePorts, pythonProfiler, datasette
%% 5. Maturity: web-edit and datasette-ports are Genesis/Custom; CodeMirror, Datasette and the profiler are Product; Tailscale is Commodity
%% 6. Management: a single maintainer wiring agent-built tools into the Datasette ecosystem
anchor developerOnPhone [0.9, 0.9]
component webEdit [0.12, 0.82]
component datasettePorts [0.28, 0.5]
component pythonProfiler [0.5, 0.45]
component codeMirror [0.6, 0.7]
component datasette [0.6, 0.62]
component tailscaleNetwork [0.82, 0.55]
codeMirror -> webEdit
tailscaleNetwork -> webEdit
webEdit -> developerOnPhone
datasettePorts -> datasette
datasettePorts -> pythonProfiler
pythonProfiler -> developerOnPhone
datasette -> developerOnPhone
evolve datasettePorts 0.4

Python 3.15

Python 3.15 is a release about reducing friction rather than raw speed. Explicit lazy imports (PEP 810) attack the startup cost that heavy plugin dependencies impose on CLI tools; unpacking in comprehensions (PEP 798) tidies a long-requested ergonomic gap; and the new Tachyon sampling profiler finally bakes py-spy-class, low-overhead stack sampling into the standard library. Performance is essentially flat against 3.14 apart from an experimental JIT that shows a real 1.2x on a Fibonacci microbenchmark. For maintainers supporting every version, the practical milestone is dropping 3.10 and finally adopting 3.11-era features. The throughline is a maturing language optimising developer and operator experience.

Watch for:

• Whether explicit lazy imports meaningfully cut CLI and plugin startup times in real tools such as llm and Datasette.
• Whether the experimental JIT graduates and delivers gains beyond microbenchmarks.
• Adoption tooling such as uv pinning and tool upgrades becoming the default way teams move to new interpreters.

Wardley signals:

• Components: Python 3.15; PEP 810 explicit lazy imports; PEP 798 unpacking in comprehensions; Tachyon sampling profiler (profiling.sampling); cProfile/profiling.tracing; experimental JIT; uv; py-spy.

• Evolution stage: Python interpreter — Commodity (ubiquitous, standardised); lazy imports and unpacking syntax — Product (accepted, standardising language features); Tachyon sampling profiler — Product (baked into stdlib, displacing third-party py-spy); JIT — Genesis/Custom (experimental, uncertain payoff); uv — Product (widely adopted tooling).

• Doctrine hits/misses: hits — “Use standards” (PEPs), “Use appropriate tools” (sampling over tracing), “Do better with less” (low-overhead profiler), “Optimise flow” (startup cost); none clearly violated.

• Climatic patterns: “Efficiency enables innovation (Componentisation effect)”; “Components can co-evolve (practice with activity)”; “Everything evolves through supply and demand competition” (the stdlib absorbing community tooling).

• Diffusion markers: standardisation via PEPs; stdlib absorption of a widely used community tool (py-spy to profiling.sampling); release-manager-curated “What’s new” guides; uv making interpreter upgrades routine.

• Hello Python 3.15, goodbye 3.10, and now I can use 3.11

wardley-beta
%% 1. Users: Python developers and package maintainers
%% 2. Needs: faster startup, better ergonomics, and low-overhead profiling
%% 3. Capabilities: lazy loading, comprehension unpacking, in-process sampling, and version management
%% 4. Components: experimentalJIT, unpackingComprehensions, lazyImports, samplingProfiler, uvToolchain, pythonInterpreter
%% 5. Maturity: JIT is Genesis; language features and profiler are Product; interpreter and uv are Commodity/Product
%% 6. Management: CPython core team, PEP authors, and the uv/Astral toolchain
anchor pythonDeveloper [0.92, 0.92]
component experimentalJIT [0.2, 0.45]
component unpackingComprehensions [0.48, 0.62]
component lazyImports [0.5, 0.68]
component samplingProfiler [0.55, 0.58]
component uvToolchain [0.62, 0.5]
component pythonInterpreter [0.85, 0.9]
unpackingComprehensions -> pythonInterpreter
lazyImports -> pythonInterpreter
samplingProfiler -> pythonInterpreter
experimentalJIT -> pythonInterpreter
uvToolchain -> pythonInterpreter
pythonInterpreter -> pythonDeveloper
evolve experimentalJIT 0.35

Bug Bounty Methodology

Sn0rkY’s interview is a case for depth over volume in bug bounty. The veteran French hunter spends months on a single program, rebuilds target services in his own labs, and treats curiosity and system understanding, not scanners, as the primary tool. He is openly dismissive of automation that produces shallow “dummy bugs”, and advises newcomers not to jump between programs or lean on off-the-shelf scanners. On AI he is pragmatic rather than evangelical: he will play with it as a tool but has no plan to become an expert. The piece is a useful counterweight to AI-hype narratives, and a reminder that triage quality and researcher relationships are platform differentiators.

Watch for:

• Whether AI-assisted scanning raises the bar toward deeper logic-class bugs or just floods triage with low-quality reports.
• Platforms competing on triage quality and researcher relationships as programs commoditise.
• The career path for hunters who invest in deep, lab-based target understanding.

Wardley signals:

• Components: Sn0rkY; YesWeHack; bug bounty programs; automated scanners; custom target labs; triage teams; logic bugs; AI hunting tools.

• Evolution stage: bug bounty platforms — Product (growing, competing, consolidating); automated scanners — Commodity (widely available, low differentiation); custom labs — Custom (bespoke, expert-built); AI hunting tools — Genesis/Custom (emerging, disputed value); triage — Product (standard service, differentiated by quality).

• Doctrine hits/misses: hits — “Know your users” and “Focus on user needs” (understand targets deeply), “Know the details”, “Bias towards data” (evidence over hype), “Use appropriate tools”; misses — “Use appropriate tools” is partly violated by hunters who over-automate and file dummy bugs.

• Climatic patterns: “Everything evolves through supply and demand competition” (platform competition); “Efficiency enables innovation (Componentisation effect)” (scanners lower the entry barrier); “You cannot measure evolution over time or adoption, you need to embrace uncertainty” (AI’s real impact is unclear).

• Diffusion markers: automation and AI lowering barriers to entry and producing noisier submissions; platform standardisation of triage and disclosure workflows; knowledge sharing through interviews, Black Hat Arsenal and Dojo.

• ‘I’m not the kind of person to rely on tooling’: Sn0rkY shares his Bug Bounty story and top tips

wardley-beta
%% 1. Users: bug bounty hunters and the platforms that triage them
%% 2. Needs: find deep, real vulnerabilities rather than shallow automated noise
%% 3. Capabilities: target understanding, lab-based testing, and quality triage
%% 4. Components: aiHuntingTools, manualRecon, targetLabs, logicBugs, triageProcess, automatedScanners
%% 5. Maturity: AI hunting tools and logic-bug discovery are Genesis; labs and recon Custom; triage Product; scanners Commodity
%% 6. Management: independent hunters and platforms such as YesWeHack
anchor bugHunter [0.9, 0.9]
component aiHuntingTools [0.12, 0.4]
component manualRecon [0.25, 0.6]
component targetLabs [0.3, 0.5]
component logicBugs [0.2, 0.78]
component triageProcess [0.55, 0.6]
component automatedScanners [0.85, 0.45]
aiHuntingTools -> manualRecon
manualRecon -> targetLabs
manualRecon -> logicBugs
targetLabs -> bugHunter
logicBugs -> bugHunter
triageProcess -> bugHunter
automatedScanners -> bugHunter
evolve aiHuntingTools 0.28

AI in Cybercrime and Vulnerability Management

This piece separates AI cybercrime hype from evidence. The author notes Microsoft’s 2026 Digital Defense Report still finds target selection and complex intrusions largely manual, and that the headline “fully autonomous attack” demo ran in a mock network with no defenders. That said, AI genuinely lowers the cost barrier for reconnaissance, vulnerability discovery and exploit development, widening the gap attackers can exploit. The core argument is the “three clocks” problem: attack surface, defensive adaptation and attacker exploitation are all accelerating, but the attacker and surface clocks move fastest. The prescription is faster, deeper, on-demand testing, including agentic pentest services, rather than complacency or panic.

Watch for:

• Whether autonomous AI attacks remain demos or cross into real, defended environments.
• The exposure-window race between attack-surface churn and defensive testing speed.
• Agentic pentest offerings maturing from marketing claims into standard, same-day testing.

Wardley signals:

• Components: Microsoft 2026 Digital Defense Report; frontier AI models; AI-assisted reconnaissance; vulnerability discovery; exploit development; unpatched application/API flaws (CWEs); Agentic Pentest; YesWeHack Vulnerability Center; traditional pentesting.

• Evolution stage: AI-assisted reconnaissance and exploit development — Custom (emerging, cost barriers falling); fully autonomous AI attacks — Genesis (unproven, mock-only); traditional pentesting — Product (mature service); agentic pentest — Genesis/Custom (new offering, disputed); vulnerability management — Product (standard practice, tooling consolidating).

• Doctrine hits/misses: hits — “Bias towards data” (evidence over hype), “Challenge Assumptions” (skepticism), “Effectiveness over efficiency” (deep testing over shallow scanning), “Use appropriate methods”; misses — over-indexing on skepticism risks a “Bias towards action” gap.

• Climatic patterns: “Everything evolves through supply and demand competition”; “Efficiency enables innovation (Componentisation effect)” (cheaper AI capabilities); “Increased stability of lower order systems increases agility & speed of re-combination”; “Change is not always linear (discontinuous & exponential change exists)”.

• Diffusion markers: AI tooling spreading to smaller criminal groups as cost barriers fall; vendor agentic-pentest offerings signalling market formation; standardised findings, reporting and same-day results as adoption markers.

• Be sceptical, but be safe

wardley-beta
%% 1. Users: security defenders and vulnerability-management teams
%% 2. Needs: keep the exposure window shorter than attackers can exploit it
%% 3. Capabilities: threat awareness, exposure discovery, and fast validated testing
%% 4. Components: autonomousAttackAgents, aiExploitDev, aiRecon, agenticPentest, unpatchedAppFlaws, vulnerabilityManagement
%% 5. Maturity: autonomous attack agents and agentic pentest are Genesis/Custom; AI recon and exploit dev Custom; app flaws and vuln management Product
%% 6. Management: criminal groups on the offensive side; security teams and vendors such as YesWeHack on the defensive side
anchor securityDefender [0.9, 0.9]
component autonomousAttackAgents [0.1, 0.3]
component agenticPentest [0.22, 0.55]
component aiExploitDev [0.25, 0.4]
component aiRecon [0.3, 0.45]
component unpatchedAppFlaws [0.6, 0.7]
component vulnerabilityManagement [0.62, 0.6]
aiRecon -> aiExploitDev
aiExploitDev -> autonomousAttackAgents
autonomousAttackAgents -> securityDefender
agenticPentest -> unpatchedAppFlaws
unpatchedAppFlaws -> vulnerabilityManagement
agenticPentest -> vulnerabilityManagement
vulnerabilityManagement -> securityDefender
evolve agenticPentest 0.35