# pyweb.dev
> AI engineering knowledge base, resource library, and autonomous agent subsystem.
> Standardized context indices, machine endpoints, and verified engineering patterns.

## Machine Entry Points & Agent APIs
- Agent Hub: https://pyweb.dev/agent
- Standard Index: https://pyweb.dev/llms.txt
- Full Context Dump: https://pyweb.dev/llms-full.txt
- Machine Knowledge Graph: https://pyweb.dev/api/graph.json
- Installable Skills Index: https://pyweb.dev/skills/index.json
- Knowledge Schema: https://pyweb.dev/wiki/schema.json
- Knowledge Changelog: https://pyweb.dev/wiki/changelog.md
- Design Spec: https://pyweb.dev/DESIGN.md
- Wiki Rules & Taxonomy: https://pyweb.dev/SCHEMA.md

## Direct Navigation
- Wiki Index: https://pyweb.dev/wiki
- Architectural Guides: https://pyweb.dev/writing
- Raw Markdown Access: append `.md` to any `/wiki/*` or `/writing/*` URL

## Wiki: Knowledge Base

### Concepts
- [AG-UI Protocol](https://pyweb.dev/wiki/ag-ui-protocol): Open, lightweight, event-based standard connecting AI agent runtimes to user-facing frontend applications.
- [Agent Containment and Blast Radius](https://pyweb.dev/wiki/agent-containment-and-blast-radius): Capping what an agent can do — not just what it tends to do — via sandboxes, VMs, egress controls, and classifier-gated approvals layered over fallible human oversight.
- [Agent Harness Engineering](https://pyweb.dev/wiki/agent-harness-engineering): Designing the runtime infrastructure around an agent's model — sandboxes, tool contracts, progressive disclosure, and verification gates — as the primary driver of reliability.
- [Agent-Native Infrastructure](https://pyweb.dev/wiki/agent-native-infrastructure): Full-stack platforms designed around machine cognition, deterministic state machines, and cryptographic agent identity rather than human developer tools.
- [Agentic Code Quality](https://pyweb.dev/wiki/agentic-code-quality): Risk-conditioned verification and authorization controls for autonomous software development.
- [Agentic Engineering Patterns](https://pyweb.dev/wiki/agentic-engineering-patterns): Disciplined software engineering practices for working with autonomous coding agents that write, test, and verify code in loops.
- [Agentic Manual Testing](https://pyweb.dev/wiki/agentic-manual-testing): Directing coding agents to actively exercise running servers, APIs, CLI one-liners, and browser automation to verify real system behaviour.
- [Agentic Software Factory](https://pyweb.dev/wiki/agentic-software-factory): Operating model for software development where autonomous AI agents perform end-to-end delivery under harness constraints and risk-tiered human oversight.
- [Agentic Vulnerability Lifecycle](https://pyweb.dev/wiki/agentic-vulnerability-lifecycle): The collapse of traditional security embargo windows and CVE disclosure pipelines driven by automated coding agents that synthesize working exploits within minutes of patch discussions.
- [Agents vs Workflows](https://pyweb.dev/wiki/agents-vs-workflows): The degree-of-autonomy spectrum from Anthropic's Building Effective Agents: workflows run on developer-defined code paths, agents direct their own process via tools and environment feedback.
- [AGENTS.md Specification](https://pyweb.dev/wiki/agents-md-spec): The root project context standard for orienting AI coding agents without system prompt bloat.
- [AI Coding Taxonomy & Agent Experience](https://pyweb.dev/wiki/ai-coding-taxonomy): Core vocabulary and operational taxonomy for AI coding agents, attention dynamics, developer/agent experience (DX/AX), and execution modes.
- [AI Engineer Role](https://pyweb.dev/wiki/ai-engineer-role): The application-layer engineer who orchestrates AI APIs, RAG, and evals — distinct from ML Engineering by the API boundary, grounded in Latent Space's 'Rise of the AI Engineer'.
- [Automated Eval Engineering](https://pyweb.dev/wiki/automated-eval-engineering): Techniques and harnesses for constructing reproducible, containerized agent evaluations from repository code and production traces.
- [Build-From-Scratch Pedagogy](https://pyweb.dev/wiki/build-from-scratch-pedagogy): Building the minimal toy version from scratch as the primary mechanism for deep understanding.
- [Claude Managed Agents](https://pyweb.dev/wiki/claude-managed-agents): Anthropic's cloud-hosted agent runtime platform decoupling reasoning loops from containerized sandbox execution.
- [Clean Architecture](https://pyweb.dev/wiki/clean-architecture): Uncle Bobs dependency-inward organizing rule applied to agent systems: source dependencies point toward stable abstractions.
- [Closed-Loop Agent Improvement](https://pyweb.dev/wiki/closed-loop-agent-improvement): End-to-end telemetry and verification architecture where production failure traces drive automated candidate PR generation and benchmark gating.
- [Codex Harness Architecture](https://pyweb.dev/wiki/codex-harness-architecture): Architecture of OpenAI's Codex harness: Clean/Hexagonal design, JSON-RPC app-server decoupling, multi-platform sandboxing, and bounded execution.
- [Cognitive Debt and Walkthroughs](https://pyweb.dev/wiki/cognitive-debt-and-walkthroughs): Techniques for understanding agent-generated code through structured linear walkthroughs and interactive explanations to prevent cognitive debt.
- [Conformance Suites as Fitness Functions](https://pyweb.dev/wiki/conformance-suites-as-fitness-functions): Pairing agents with uncompromising deterministic test suites so they act as autonomous optimization engines instead of drifting generators.
- [Constraint Layering](https://pyweb.dev/wiki/constraint-layering)
- [Context Budget Audit](https://pyweb.dev/wiki/context-budget-audit): Measuring and cutting per-turn token overhead — /context, logging proxies, disable flags, and deny rules to kill harness bloat.
- [Context Engineering](https://pyweb.dev/wiki/context-engineering): Curating high-signal context (AGENTS.md, CONTEXT.md, ADRs) to maximize agent reasoning performance.
- [Context Rot](https://pyweb.dev/wiki/context-rot): The progressive degradation of LLM reasoning performance as context length and irrelevant tokens accumulate.
- [Cordis Framework](https://pyweb.dev/wiki/cordis-framework): Microkernel plugin and dependency-injection framework powering DeepSeek Harness: lifecycle management, service containers, typed event buses, reversible side-effects.
- [DeepSeek Harness](https://pyweb.dev/wiki/deepseek-harness): DeepSeek's open-source agent runtime built on the Agent = Model + Harness thesis: modular, traceable execution without hardcoded core logic.
- [Dependency Inversion Principle](https://pyweb.dev/wiki/dependency-inversion-principle)
- [Dependency Rule](https://pyweb.dev/wiki/dependency-rule)
- [Designing for Verifiability](https://pyweb.dev/wiki/designing-for-verifiability): 'It's hard to eval' is a product smell — artifacts hard for you to verify are hard for users too; design checkable artifacts before building evals.
- [Deterministic Lint Gates](https://pyweb.dev/wiki/deterministic-lint-gates): Rust-speed linters with error-only configs as the Tier 1 mechanical backpressure layer for agentic coding loops.
- [Editorial Diagrams and Visual Explanations](https://pyweb.dev/wiki/editorial-diagrams-and-visual-explanations): Design principles, semantic patterns, and standards for generating high-signal, self-contained visual diagrams in agentic workflows.
- [Error Analysis and Evals](https://pyweb.dev/wiki/error-analysis-and-evals): Qualitative inspection of production traces to discover failure modes, build domain-specific taxonomies, and derive trustworthy evaluation rubrics.
- [Eval Taxonomy](https://pyweb.dev/wiki/eval-taxonomy): Evals as the AI engineer's unit tests: deterministic pass/fail checks, LLM-as-judge smoke tests, and human feedback — three tiers for wrangling predictability from probabilistic systems.
- [Eval-Driven Development](https://pyweb.dev/wiki/eval-driven-development): Iterative, trace-grounded engineering discipline for discovering, encoding, and continuously testing GenAI failure modes.
- [Evals Skills](https://pyweb.dev/wiki/evals-skills)
- [First-Principles Thinking](https://pyweb.dev/wiki/first-principles-thinking): Stripping complex problems to fundamental verifiable truths and rebuilding solutions upward.
- [Five Debts of Agentic Engineering](https://pyweb.dev/wiki/five-debts-of-agentic-engineering)
- [Generator-Evaluator Loop](https://pyweb.dev/wiki/generator-evaluator-loop): Generate then adversarially evaluate: a proposal loop where a separate evaluator checks each output against explicit criteria.
- [Git for Agentic Workflows](https://pyweb.dev/wiki/git-for-agentic-workflows): Leveraging coding agents' native git fluency to explore repo history, resolve complex merge conflicts, bisect bugs, and rewrite clean commit stories.
- [Grill With Docs](https://pyweb.dev/wiki/grill-with-docs): Stateful interactive alignment skill that captures domain vocabulary into CONTEXT.md and three-gated decisions into ADRs.
- [Grilling Doctrine](https://pyweb.dev/wiki/grilling-doctrine): Relentless adversarial interview methodology to sharpen architecture and surface assumptions before coding.
- [Handoff Artifacts](https://pyweb.dev/wiki/handoff-artifacts): Structured, self-contained markdown documents that bridge context across session boundaries and multi-agent workflows.
- [Hexagonal Architecture](https://pyweb.dev/wiki/hexagonal-architecture)
- [Hoard and Recombine](https://pyweb.dev/wiki/hoard-and-recombine): Collecting verified working code snippets and proof-of-concept tools to supply as concrete reference material for coding agents.
- [Idea-to-Ship Flow](https://pyweb.dev/wiki/idea-to-ship-flow): End-to-end disciplined engineering workflow moving from grilled ideas to specs, tickets, and verified PRs.
- [Karpathy's Four Guidelines](https://pyweb.dev/wiki/karpathy-four-guidelines): Four foundational coding conduct rules for agents: Think Before Coding, Simplicity First, Surgical Changes, Goal-Driven.
- [LLM App Improvement Ladder](https://pyweb.dev/wiki/llm-app-improvement-ladder): Matt Pocock's ordered ladder of 17 techniques for improving an LLM-powered app — from prompt basics to fine-tuning — try the simple thing first.
- [LLM Message Protocol](https://pyweb.dev/wiki/llm-message-protocol): The message-based conversation protocol between application and LLM: system prompts, user/assistant messages, tool calls, and tool results.
- [LLM Wiki Pattern](https://pyweb.dev/wiki/llm-wiki-pattern): Compounding, interlinked markdown knowledge base pattern curated autonomously by agents.
- [Model Context Protocol Basics](https://pyweb.dev/wiki/model-context-protocol-basics): MCP as the standardized bridge between LLM applications and external tools/data — the client-server layer beneath tool calling.
- [Model Provider Abstraction](https://pyweb.dev/wiki/model-provider-abstraction): Why production LLM apps need a provider-neutral interface — and the real switching cost when you code directly against one vendor's API.
- [Multi-Agent Orchestration](https://pyweb.dev/wiki/multi-agent-orchestration): Hierarchical agent swarms where engineers orchestrate fleets of specialized agents in parallel isolated worktrees: coder to conductor to orchestrator.
- [Onion Architecture](https://pyweb.dev/wiki/onion-architecture)
- [Progressive Disclosure](https://pyweb.dev/wiki/progressive-disclosure): Providing context and tooling to AI agents in staged layers on-demand rather than up front.
- [Prompt Bloat](https://pyweb.dev/wiki/prompt-bloat): The accumulation of redundant, generic, or conflicting instructions in system prompts that degrades agent performance.
- [Red/Green TDD](https://pyweb.dev/wiki/red-green-tdd): Test-first development where failing tests are observed before writing minimal implementation code - the core discipline for coding agents.
- [Releasable Patch Rate](https://pyweb.dev/wiki/releasable-patch-rate)
- [Site-as-Eval-Subject Grading](https://pyweb.dev/wiki/site-as-eval-subject-grading): Grading a static site with deterministic graders and LLM judges, then hill-climbing the design against the scorecard.
- [Skill Treatment Effect](https://pyweb.dev/wiki/skill-treatment-effect)
- [Smart Zone](https://pyweb.dev/wiki/smart-zone): The optimal token window where frontier LLMs maintain peak reasoning sharpness before attention degradation sets in.
- [Software Engineering Fundamentals for Agents](https://pyweb.dev/wiki/software-engineering-fundamentals-for-agents)
- [Structured Outputs](https://pyweb.dev/wiki/structured-outputs): Constraining LLM responses to JSON-schema shapes — objects, enums, arrays — for data extraction and classification, with streaming and tool-based variants.
- [Subagents and Context Management](https://pyweb.dev/wiki/subagents-and-context-management): Preserving root conversation context by dispatching isolated sub-agents for repo exploration, testing, debugging, and file edits.
- [TDD With Agents](https://pyweb.dev/wiki/tdd-with-agents): Rigorous test-driven development loop using executable tests as the truth referee for coding agents.
- [The Feynman Technique](https://pyweb.dev/wiki/feynman-technique): Teaching and learning methodology: plain English explanations, identifying gaps, and radical simplification.
- [Think Tool](https://pyweb.dev/wiki/think-tool): Anthropic's technique of giving an LLM a no-op 'think' tool so it can persist structured reasoning into context before complex tool calls.
- [Tool Calling Loop](https://pyweb.dev/wiki/tool-calling-loop): The four-step agentic loop — specify tools, receive tool calls, execute locally, return results — that lets LLMs act on the world.
- [Tracer Bullets](https://pyweb.dev/wiki/tracer-bullets): Shipping the thinnest end-to-end slice through all architecture layers before expanding features.

### Entities
- [Addy Osmani](https://pyweb.dev/wiki/addy-osmani): Engineering leader and author writing on agent harness engineering, agentic code quality gates, and software factory workflows.
- [Aditi Raghunathan](https://pyweb.dev/wiki/aditi-raghunathan)
- [Ahmed E. Hassan](https://pyweb.dev/wiki/ahmed-e-hassan)
- [Airbnb](https://pyweb.dev/wiki/airbnb): Global travel marketplace and engineering pioneer in industrial Eval-Driven Development (EDD) for generative AI applications.
- [Alistair Cockburn](https://pyweb.dev/wiki/alistair-cockburn)
- [Andrei Botocan](https://pyweb.dev/wiki/andrei-botocan)
- [Andrej Karpathy](https://pyweb.dev/wiki/andrej-karpathy): AI researcher, educator, Stanford CS231n co-creator, and developer of the build-from-scratch pedagogy.
- [Andrew Ng](https://pyweb.dev/wiki/andrew-ng)
- [Anil Madhavapeddy](https://pyweb.dev/wiki/anil-madhavapeddy)
- [Anthropic](https://pyweb.dev/wiki/anthropic): AI safety research company developing Claude LLM models and researching agent systems.
- [Armin Ronacher](https://pyweb.dev/wiki/armin-ronacher): Software engineer critiquing coordination friction loss in agent-accelerated development.
- [Beatrice Casey](https://pyweb.dev/wiki/beatrice-casey)
- [Beth Barnes](https://pyweb.dev/wiki/beth-barnes)
- [Boris Cherny](https://pyweb.dev/wiki/boris-cherny): Engineering leader at Anthropic, creator of Claude Code, and author of Programming TypeScript.
- [Brittany Reid](https://pyweb.dev/wiki/brittany-reid)
- [Cathryn Lavery](https://pyweb.dev/wiki/cathryn-lavery): Designer, entrepreneur, and author of Diagram Design; pioneer of editorial visual design systems and semantic diagramming for AI coding agents.
- [Christoph Csallner](https://pyweb.dev/wiki/christoph-csallner)
- [Christoph Nakazawa](https://pyweb.dev/wiki/christoph-nakazawa)
- [CopilotKit](https://pyweb.dev/wiki/copilotkit): Open-source AI Copilot framework and creators of the AG-UI protocol for agent-user interaction.
- [Cursor](https://pyweb.dev/wiki/cursor): AI-powered code editor company pioneering hierarchical agent systems for autonomous coding.
- [David Gros](https://pyweb.dev/wiki/david-gros)
- [David Rein](https://pyweb.dev/wiki/david-rein)
- [DeepSeek](https://pyweb.dev/wiki/deepseek): AI research company behind frontier open-weights models and the DeepSeek Harness agent runtime developer preview.
- [Dipayan Banik](https://pyweb.dev/wiki/dipayan-banik)
- [DORA](https://pyweb.dev/wiki/dora)
- [Drew Breunig](https://pyweb.dev/wiki/drew-breunig): Writer on LLM economics; argued in 'Fable & The End of the Free Lunch' that high frontier-model pricing ended the era when new models papered over weak harnesses.
- [Dung Nguyen Manh](https://pyweb.dev/wiki/dung-nguyen-manh)
- [Eirini Kalliamvakou](https://pyweb.dev/wiki/eirini-kalliamvakou)
- [Epoch AI](https://pyweb.dev/wiki/epoch-ai)
- [Florian Brand](https://pyweb.dev/wiki/florian-brand)
- [Gelei Deng](https://pyweb.dev/wiki/gelei-deng)
- [Gergely Orosz](https://pyweb.dev/wiki/gergely-orosz): Author of The Pragmatic Engineer newsletter, covering tech industry trends, engineering leadership, and developer tooling in the agentic era.
- [GitHub](https://pyweb.dev/wiki/github): Leading software development platform, developer of Copilot, and author of the Spec-Driven Development toolkit for AI agents.
- [Hajimu Iida](https://pyweb.dev/wiki/hajimu-iida)
- [Hamel Husain](https://pyweb.dev/wiki/hamel-husain): AI product engineer, machine learning educator, and specialist in LLM evaluation, error analysis, and domain-grounded AI systems.
- [Hao Li](https://pyweb.dev/wiki/hao-li)
- [Haoxiang Zhang](https://pyweb.dev/wiki/haoxiang-zhang)
- [Hiroshi Iwata](https://pyweb.dev/wiki/hiroshi-iwata)
- [Huy Nhat Phan](https://pyweb.dev/wiki/huy-nhat-phan)
- [Ivan Bercovich](https://pyweb.dev/wiki/ivan-bercovich)
- [Ivar Jacobson](https://pyweb.dev/wiki/ivar-jacobson)
- [Ivgeni Segal](https://pyweb.dev/wiki/ivgeni-segal)
- [James Coplien](https://pyweb.dev/wiki/james-coplien)
- [James Shore](https://pyweb.dev/wiki/james-shore): Software engineering consultant analyzing economic implications of AI-accelerated development.
- [Jarred Sumner](https://pyweb.dev/wiki/jarred-sumner): Creator of Bun, who led autonomous agent-driven rewrite of Bun's codebase from Zig to Rust.
- [Jean-Stanislas Denain](https://pyweb.dev/wiki/jean-stanislas-denain)
- [Jeffrey Palermo](https://pyweb.dev/wiki/jeffrey-palermo)
- [Joanna C. S. Santos](https://pyweb.dev/wiki/joanna-c-s-santos)
- [Joel Becker](https://pyweb.dev/wiki/joel-becker)
- [Johann Rehberger](https://pyweb.dev/wiki/johann-rehberger): Security researcher warning about normalization of deviance in AI system permissions.
- [K M Ferdous](https://pyweb.dev/wiki/k-m-ferdous)
- [Ken’ichi Yamaguchi](https://pyweb.dev/wiki/kenichi-yamaguchi)
- [Kent Beck](https://pyweb.dev/wiki/kent-beck): Pioneer of Extreme Programming (XP), Test-Driven Development (TDD), co-author of the Agile Manifesto, and author writing on AI coding workflows.
- [Kexun Zhang](https://pyweb.dev/wiki/kexun-zhang)
- [Kowshik Chowdhury](https://pyweb.dev/wiki/kowshik-chowdhury)
- [Lalit Maganti](https://pyweb.dev/wiki/lalit-maganti): Syntaqlite creator documenting where coding agents help implementation and harm unresolved design work.
- [Leo Yu Zhang](https://pyweb.dev/wiki/leo-yu-zhang)
- [Maliheh Izadi](https://pyweb.dev/wiki/maliheh-izadi)
- [Mario Zechner](https://pyweb.dev/wiki/mario-zechner): Software engineer warning about compounding errors in high-velocity agent development.
- [Martin Fowler](https://pyweb.dev/wiki/martin-fowler): Author, chief scientist at ThoughtWorks, and foundational thinker on software architecture, refactoring, and AI-assisted engineering practices.
- [Matt Pocock](https://pyweb.dev/wiki/matt-pocock): TypeScript and AI engineering educator behind the idea-to-ship workflow and deep module design.
- [Mert Demirer](https://pyweb.dev/wiki/mert-demirer)
- [Miku Watanabe](https://pyweb.dev/wiki/miku-watanabe)
- [Minh Vu Thai Pham](https://pyweb.dev/wiki/minh-vu-thai-pham)
- [Model Evaluation & Threat Research](https://pyweb.dev/wiki/model-evaluation-and-threat-research)
- [Mohammed Latif Siddiq](https://pyweb.dev/wiki/mohammed-latif-siddiq)
- [Nat Pryce](https://pyweb.dev/wiki/nat-pryce)
- [Nate Rush](https://pyweb.dev/wiki/nate-rush)
- [Nghi D. Q. Bui](https://pyweb.dev/wiki/nghi-d-q-bui)
- [Nick Craig-Wood](https://pyweb.dev/wiki/nick-craig-wood)
- [OpenAI](https://pyweb.dev/wiki/openai): AI research and deployment company developing GPT models, ChatGPT, Codex, and agent harness infrastructure.
- [Peter Cihon](https://pyweb.dev/wiki/peter-cihon)
- [Prem Devanbu](https://pyweb.dev/wiki/prem-devanbu)
- [Prithvi Rajasekaran](https://pyweb.dev/wiki/prithvi-rajasekaran)
- [Rahul Pandita](https://pyweb.dev/wiki/rahul-pandita)
- [Razvan Mihai Popescu](https://pyweb.dev/wiki/razvan-mihai-popescu)
- [Richard Feynman](https://pyweb.dev/wiki/richard-feynman): Nobel laureate physicist known for first-principles thinking, joyful curiosity, and plain-language pedagogy.
- [Robert C. Martin (Uncle Bob)](https://pyweb.dev/wiki/robert-c-martin)
- [Sabrina Haque](https://pyweb.dev/wiki/sabrina-haque)
- [Sarvesh Ingale](https://pyweb.dev/wiki/sarvesh-ingale)
- [Shashwat Saxena](https://pyweb.dev/wiki/shashwat-saxena)
- [Shazibul Islam Shamim](https://pyweb.dev/wiki/shazibul-islam-shamim)
- [Shopify](https://pyweb.dev/wiki/shopify): E-commerce platform company conducting autonomous agent optimization experiments.
- [Shota Sawada](https://pyweb.dev/wiki/shota-sawada)
- [Shreya Shankar](https://pyweb.dev/wiki/shreya-shankar): Computer science researcher at UC Berkeley focusing on data management, ML systems, and active-learning tooling for LLM error analysis and evaluation.
- [Sida Peng](https://pyweb.dev/wiki/sida-peng)
- [Simon Willison](https://pyweb.dev/wiki/simon-willison): Software engineer, creator of Datasette, co-creator of Django, and prominent authority on LLM tooling, evals, and agentic engineering patterns.
- [Steve Freeman](https://pyweb.dev/wiki/steve-freeman)
- [Stripe](https://pyweb.dev/wiki/stripe): Financial infrastructure platform conducting benchmark research on autonomous coding agents building production payment integrations.
- [Tatsuya Shirai](https://pyweb.dev/wiki/tatsuya-shirai)
- [Tessl](https://pyweb.dev/wiki/tessl): AI software development company researching developer platforms, agentic software engineering benchmarks, and system harness architectures.
- [Tobias Lütke](https://pyweb.dev/wiki/tobias-lutke): Shopify CEO who conducted autonomous agent optimization of Liquid template engine.
- [Trygve Reenskaug](https://pyweb.dev/wiki/trygve-reenskaug)
- [Tue Le](https://pyweb.dev/wiki/tue-le)
- [Vercel](https://pyweb.dev/wiki/vercel): Frontend platform company; creator of the AI SDK, a provider-neutral TypeScript interface for LLM generation, streaming, and tool calling.
- [Vinicius Carvalho Lopes](https://pyweb.dev/wiki/vinicius-carvalho-lopes)
- [Viv Trivedy](https://pyweb.dev/wiki/viv-trivedy): Practitioner credited by Addy Osmani with naming harness engineering and articulating the model-plus-harness framing.
- [Wes McKinney](https://pyweb.dev/wiki/wes-mckinney): Creator of pandas, POSIT; pioneer of high-throughput agentic engineering harness workflows and automated post-commit review.
- [Wilson Lin](https://pyweb.dev/wiki/wilson-lin): Cursor researcher documenting planner-worker architectures for long-running autonomous coding.
- [Xinye Zhao](https://pyweb.dev/wiki/xinye-zhao)
- [Yanjun Zhang](https://pyweb.dev/wiki/yanjun-zhang)
- [Yi Liu](https://pyweb.dev/wiki/yi-liu)
- [Ying Zhang](https://pyweb.dev/wiki/ying-zhang)
- [Yubin Qu](https://pyweb.dev/wiki/yubin-qu)
- [Yuekang Li](https://pyweb.dev/wiki/yuekang-li)
- [Yutaro Kashiwa](https://pyweb.dev/wiki/yutaro-kashiwa)
- [Ziqian Zhong](https://pyweb.dev/wiki/ziqian-zhong)

### Comparisons
- [Agentic Code Quality — Evidence Map](https://pyweb.dev/wiki/agentic-quality-evidence)

### Queries
- [Agentic Code Quality Cycle 2 — Entity Accounting](https://pyweb.dev/wiki/agentic-code-quality-cycle-2-entity-accounting)
- [Agentic Code Quality Evidence — Entity Accounting](https://pyweb.dev/wiki/agentic-code-quality-entity-accounting)
- [Agentic Engineering Entity Accounting](https://pyweb.dev/wiki/agentic-engineering-entity-accounting): Entity disposition query documenting the 2026-08-24 ingestion of agentic engineering trends synthesis
- [LLM Wiki Ecosystem: Spec vs. Implementations](https://pyweb.dev/wiki/llm-wiki-ecosystem-analysis): Comparative query analyzing the LLM Wiki specification against real-world implementations, including this site.

## Writing
- [The Agentic Engineering Curriculum](https://pyweb.dev/writing/agentic-engineering-curriculum): A structured course on AI engineering and agentic patterns, distilled from the wiki: foundations, context, evals, verification, harnesses, and the software factory.
- [The Linter Is the Cheapest Adult in the Room](https://pyweb.dev/writing/the-linter-is-the-cheapest-adult-in-the-room): Why Rust-speed, error-only lint gates like Oxlint are the Tier 1 backpressure layer that keeps autonomous coding loops honest — with the failure modes they mechanically close.
- [The Agent as a Virtual OS: Inside the Codex Harness Architecture](https://pyweb.dev/writing/the-agent-as-a-virtual-os-codex-harness-architecture): Dissecting OpenAI's Codex harness: JSON-RPC app-server decoupling, multi-platform OS sandboxing, bounded context streams, and the lessons of production agent design.
- [The Five Debts of Agentic Engineering](https://pyweb.dev/writing/five-debts-of-agentic-engineering): Why probabilistic coding generators accumulate intent, semantic, verification, architecture, and authorization debt—and how risk-conditioned systems keep autonomous loops releasable.
- [Clean Architecture for Agent Harnesses](https://pyweb.dev/writing/clean-architecture-for-agent-harnesses): How Uncle Bob's 2012 Dependency Rule and boundary isolation principles solve the durability, containment, and testability crises in modern AI agent harnesses.
- [Skills-Native Evaluation and Agent Adversarial Training](https://pyweb.dev/writing/skills-native-evaluation-agent-adversarial-training): How evaluation methodology shipped as installable skills and GAN-inspired generator-evaluator loops are advancing AI agent reliability beyond prompt tweaks.
- [Loop and Graph Engineering: The Dual Topologies of Agentic Systems](https://pyweb.dev/writing/loop-and-graph-engineering): Why single-agent prompt loops degrade past the smart zone, and how graph orchestration provides the structural partition needed for production AI systems.
- [Hello world](https://pyweb.dev/writing/hello-world): The first post on pyweb.dev
- [Building Effective Agentic Workflows](https://pyweb.dev/writing/building-effective-agentic-workflows): A practitioner's architectural guide to building reliable AI coding agents: avoiding context rot, operating in the smart zone, and enforcing tight engineering loops.