The article explains the two main AI Agent Loop patterns—human‑in‑the‑loop and fully autonomous agentic loops—highlights the hidden costs, product‑drift risks, and budget limits of the latter, and provides concrete, low‑risk scenarios and a step‑by‑step code‑review loop that keeps humans in control.
Although AI tools like Copilot and Cursor can cut coding time from five days to three, the saved time is quickly filled with additional tasks, leading to higher output expectations, increased technical debt, and greater mental fatigue for developers, as organizations reap the productivity gains without reducing individual workload.
The article analyzes how AI‑assisted “Vibe Coders” focus on rapid prototype creation while software engineers prioritize full‑lifecycle responsibilities, proposing a new “safe‑merge time” metric to evaluate code quality, discussing responsibility boundaries, context awareness, appropriate use cases, and the impact on junior developers.
The article examines Oh My OpenAgent’s “ulw” command, which triggers a fully automated, multi‑agent AI development pipeline that writes, tests, documents, and secures code without human intervention, compares its speed and quality to traditional AI assistants, and extracts engineering lessons for building reliable, cost‑effective AI‑driven development platforms.
Superpowers augments Claude Code with a strict engineering workflow—clarify, design, plan, execute, verify—turning rapid but error‑prone code generation into a one‑shot, reliable process, as demonstrated by a detailed subscription‑payment frontend case study and extensive analysis of its underlying skills and probability control techniques.
Agent Skills, an open‑source project by Google engineer Addy Osmani, breaks the software development lifecycle into six stages with 24 structured skills, anti‑rationalization checks, doubt‑driven development, and context engineering, enabling AI‑generated code to meet production‑grade quality standards.
The article explains why code review matters, how it should be performed, and how the rise of AI‑generated code reshapes review practices, introducing a five‑level review taxonomy and a methodology that combines atomic pull requests, layered reading, comment grading, and measurable SLAs.
The article examines how SpaceX’s software teams—covering flight control, enterprise information systems, ground launch‑pad software, and avionics testing—use a diverse tech stack to ensure real‑time reliability, illustrating that rockets rely on both fuel and code to reach orbit.
The article explains how AI programming is shifting from manual Prompt Engineering to a Loop Engineering approach that builds repeatable, observable, and self‑correcting work cycles, detailing its components, benefits, risks, and practical workflow for sustainable agent collaboration.
Loop Engineering shifts focus from one‑off prompt engineering to continuous feedback loops that discover work, assign tasks, verify results, and record state, showing that the more automated the loop becomes, the more essential human judgment remains to define goals, budgets, and stop conditions.
The article reviews Anthropic's newly released Claude Fable 5, compares its pricing, benchmark scores, and real‑world coding performance against Claude Opus 4.8 and GPT‑5.5, and concludes that while Fable 5 delivers the most reliable, out‑of‑the‑box results, its cost makes it suitable only for high‑value, complex projects.
AI model benchmarkingClaude Fable 5Claude Opus 4.8
The article proposes using invariants—conceptual, connection, runtime, and class-level constraints—to formalize software structure, enabling correct-by-construction code generation by AI agents instead of relying on post-hoc verification.
Meta’s recent paper presents AutoformBot, a multi‑agent system that treats formalizing entire mathematics textbooks as a large‑scale software‑engineering project, generating the ATLAS Lean 4 library with over 45,000 declarations and demonstrating a 71 % success rate across 26 open‑access books.
Anthropic released two new Claude models—Fable 5, open to all users with a safety classifier, and Mythos 5, a restricted, high‑security version—both achieving record‑breaking performance on software‑engineering, research, vision, and long‑context tasks, while offering a pricing model of $10 per M input tokens and $50 per M output tokens.
Recent coding agents like Claude Code and Codex expose a deeper challenge: beyond generating correct code, agents must manage long‑term tasks by continuously planning, executing, testing, and updating code, making code the executable, inspectable, stateful medium that powers the Agent Harness framework.
Anthropic has launched Claude Fable 5, its most powerful LLM to date, claiming top‑tier results across software engineering, knowledge work, vision and scientific benchmarks, while offering higher token efficiency, new safety layers, and a pricing model of $10 per M input and $50 per M output tokens.
Anthropic’s Claude Fable 5 and Mythos 5 launch with benchmark‑leading performance across software engineering, knowledge work, vision and long‑context tasks, safety‑graded access, and live demos that generate full video games from a single prompt, while pricing and phased rollout are detailed.
FrontierCode, a new benchmark from Cognition AI, shows that leading models like Claude Opus 4.8 score only 13.4% on mergeability tasks, exposing a huge gap between code that runs and code that can actually be merged into production projects.
The Agentic AICon Shanghai conference (June 5‑6) brought together 15 forum organizers and 69 speakers to explore AI‑for‑software‑engineering and software‑engineering‑for‑AI, launch the ADPS open‑source design‑pattern project, and deliver concrete architectural, evaluation and commercialization insights for AI agents.
In 2026, AI-driven development moves from simple code suggestions to autonomous, collaborative multi‑agent teams that can understand requirements, design, code, test, and self‑correct, turning programming into an industrialized, process‑focused practice where engineers act as overseers rather than sole coders.
The article defines Harness Engineering as the system that couples AI models with constraints, feedback loops, and documentation, explains why the agent alone is insufficient, details five concrete harness artifacts and five universal principles derived from OpenAI, Anthropic and ThoughtWorks case studies, and reveals the paradox that harnesses must be built to be removed as models improve.
The article details a practical AI‑driven development workflow built on OpenSpec and SuperPowers for a 200,000‑line Flutter‑Node music app, explaining how dual documentation (AGENTS.md and START_HERE.md), sub‑agent review loops, and a single‑command execution model enforce strict engineering constraints, reduce hallucinations, and automate code delivery.
OpenAI’s Codex team started from an empty repository and, by relying solely on AI‑generated application logic, tests, CI configurations and documentation, built a commercial‑grade software product in one‑tenth the usual development time, detailing roles, repository knowledge, agent legibility, architecture constraints, and iterative autonomy.
OpenAI’s five‑month experiment showed that by replacing manual coding with an "agent‑first" workflow—designing environments, building scaffolding, and automating feedback loops—engineers can produce a million lines of code, 1,500 PRs, and a fully functional product while spending only a tenth of the time traditionally required.
In the AI era, the article analyzes how AI reshapes computer science and software engineering majors, showing that low‑end coding jobs are being replaced while high‑end architecture and AI‑focused roles surge, and provides a tiered major ranking, score‑based recommendations, university selection criteria, and four‑year study pitfalls to guide 2026 Gaokao applicants.
The article explains that the instability of AI‑generated code stems from treating programming as a stateless conversation, and introduces Harness Engineering—a 2025‑born methodology that externalizes decisions to files, structures work into staged processes, and atomizes tasks to make AI coding repeatable, auditable and evolvable, while outlining emerging frameworks and a 12‑part learning path.
The article argues that AI coding tools expose engineers' hidden assumptions, forcing them to document tacit knowledge, distinguish explicit from implicit rules, and transform personal judgment into reusable, AI‑readable assets through structured markdown files and regular retrospectives.
In an interview, Boris Cherny, a core builder of Anthropic’s Claude Code, argues that human "taste" is not a lasting moat, explains how increasingly capable coding agents are reshaping productivity, organizational structures, and hiring criteria toward generalist talent and token‑driven experimentation.
OpenAI’s Symphony transforms a Codex‑only development experiment into a task‑driven workflow where each open issue is continuously handled by an autonomous agent, dramatically reducing context‑switch costs and boosting productivity across large codebases.
The article argues that Conventional Commits is a harmful anti‑pattern because it puts the optional type before the far more important scope, promises automatic changelogs and version bumps that don’t work, and proposes the proven scoped‑commit format used by Linux, Git, Go and others.
The article dissects Anthropic’s Superpowers brainstorming skill, showing how its HARD‑GATE, YAGNI‑first, and double‑review mechanisms force a design‑then‑plan‑then‑implement workflow that curbs AI’s tendency to code without proper clarification, ultimately reducing rework and improving delivery quality.
The article analyzes the shortcomings of ad‑hoc Vibe Coding, introduces Spec‑Driven Development as a structured AI‑assisted workflow, details a nine‑step process with concrete commands and examples, evaluates its trade‑offs, and offers practical guidance on when and how to apply it in team projects.
In a detailed account, Fiona Fung explains how Anthropic’s Claude Code team eliminated the coding bottleneck by relying entirely on AI‑generated code for four months, reshaping planning, information flow, code review, role boundaries, and hiring practices while tracking new performance metrics.
AI code generationcode review automationjust‑in‑time planning
The article explains that while AI code generators like Codex, Cursor, and Claude Code are powerful, teams often suffer from lost context, missing requirement clarification, lack of validation, and no knowledge retention, and proposes an open‑source superpowers‑openspec skill library that introduces structured workflows, memory mechanisms, and delivery standards to turn AI into a stable, collaborative engineering partner.
The author recounts a decade‑long evolution from writing simple CRUD code and fixing login bugs to leading system architecture design, highlighting the shifting mindset, key learning milestones, and practical advice for developers seeking to grow beyond code to strategic engineering roles.
Career DevelopmentSystem Designsoftware architecture
The Claude Code team’s engineering director shares five core principles—shifting bottlenecks, Just‑In‑Time planning, pervasive automation, trust‑but‑verify code review, and a flat, role‑agnostic team structure—illustrated with concrete examples and actionable guidelines for AI‑native organizations.
As AI coding agents like Claude Code, Cursor, and Codex become common in development pipelines, this article outlines five concrete quality‑control mechanisms—feedback sensors, semantic evaluations, refactor boundaries, provenance trails, and agent surface inventories—detailing tools, trade‑offs, and suitable scenarios to ensure generated code is trustworthy before entering a pull request.
The article proposes a systematic Agent Skill Hub that organizes, versions, releases, deploys, and rolls back AI Agent capabilities using software‑package‑style practices, illustrated with a concrete image‑download skill, directory conventions, metadata files, and a Spring AI Alibaba runtime loading strategy.
The article explains software architecture through a relatable boss‑story, defines architecture as a blueprint, outlines why architects are valuable, maps lofty business goals to concrete architectural challenges, and lists the career benefits of mastering architectural thinking.
Career DevelopmentSystem Designsoftware architecture
Google’s I/O 2026 talk warns that AI‑driven code generation can amplify output tenfold, but without solid fundamentals the resulting software ecology—code review, build times, testing, and dependency management—will collapse, making engineers the true bottleneck.
Using Git worktree to isolate AI‑generated changes lets Codex safely tackle multiple Spring Boot tasks—bug fixes, test additions, and validation analysis—without contaminating the main codebase, enabling clear diffs, easy review, and controlled integration, which the author argues is essential for engineering‑scale AI coding.
The article analyses experiments with Claude Code dynamic workflows and a 50‑hour timetravel‑agent prototype, exposing how long‑running AI coding tasks drift without proper verification gates and proposing a four‑step gate framework to ensure convergence, evidence collection, and reliable engineering outcomes.
Claude’s new Dynamic Workflows move planning and coordination out of the chat context into executable JavaScript, enabling hundreds of parallel sub‑agents, adversarial verification, and checkpoint recovery, which the article demonstrates with a Bun migration case study, a novel‑generation workflow, and detailed architectural analysis.
This guide maps the vast programming landscape, outlines major technical tracks, defines four career stages with concrete milestones, and highlights essential soft skills, helping developers navigate from their first code to senior or specialist roles.
Claude's Opus 4.8 upgrade introduces modest performance gains, stronger honesty, and a new dynamic‑workflows feature that lets the model orchestrate dozens of sub‑agents to tackle large‑scale coding tasks such as full‑repo bug hunts, migrations, and security audits.
The article analyzes how AI agents have transformed software engineering over the past three years, redefining programming from hand‑written code to prompt‑driven development, and argues that engineers must shift from writing code to orchestrating intelligent agents to stay relevant.
Anthropic's Claude Opus 4.8 improves judgment and autonomous task handling, adds a 2.5× faster "fast mode" at one‑third price, and introduces dynamic workflows that orchestrate hundreds of sub‑agents for large‑scale engineering tasks, though with higher token consumption.
The article argues that in the AI era, writing specifications, rules, and evaluation sets forces engineers to externalize tacit knowledge, turning AI from a tool into a mirror that reveals hidden assumptions, and warns that this legibility brings both powerful benefits and profound risks.
The article dissects Anthropic’s official guidance on deploying Claude Code in massive codebases, showing that context overflow stems from an inadequate harness rather than model size, and presents seven concrete pitfalls with solutions—including limiting CLAUDE.md to 200 lines, using LSP, initializing in subdirectories, leveraging hooks, skills, plugins, and MCP integration—to make the AI coding assistant effective at scale.
The article argues that engineers who prioritize flashy technologies over business value quickly hit a career ceiling, illustrating the danger with over‑engineered micro‑service splits, costly AI projects, and loss of judgment, then offers practical habits and advice to align technology with real business outcomes.
Career Developmentbusiness alignmentsoftware architecture
The article analyzes why AI agents often fail in production, distinguishes Agent Harness from Harness Engineering, outlines the three pillars of Harness Engineering, compares Vibe Coding, Spec Coding and Harness Engineering, and examines real‑world implementations by Salesforce, SAP and UiPath.
Thorsten Ball outlines twelve decisive observations about the AI era, arguing that abundant code, the rise of autonomous agents, shifting bottlenecks, and new value drivers will fundamentally rewrite software development, organization, and engineer roles.
The article analyses Claude Code's Subagents, Agent View, and Agent Teams, explaining when to use each, how to partition engineering work, enforce permission and budget limits, and gather verifiable evidence so that multiple AI agents can collaborate safely and efficiently in real projects.
The article explains how teams can successfully scale Claude Code across large monorepos by establishing clear entry points, layered rules, noise filtering, and automated checks through an Agent Harness framework that turns tacit knowledge into reusable, team‑wide assets.
The article argues that the rise of AI‑driven code generation demands a three‑stage Software Engineering 3.0 methodology—context, steering, and knowledge engineering—to turn massive efficiency gains into trustworthy, scalable production systems, making it essential for competitive enterprises.
The article analyzes how AI‑native products reshape traditional software by processing unstructured data with LLMs, adding a semantic layer that understands, calls, outputs, and learns from business context, thereby turning rapid business changes into traceable, reusable system capabilities.
The talk shows that true AI‑native development requires upgrading specifications, redesigning the entire development pipeline, establishing closed‑loop feedback, and layering rollout by business type, rather than merely adding an AI coding assistant, and presents data from ten pilot projects demonstrating efficiency gains.
The article shares five concrete habits—understanding before coding, proactive progress syncing, asking good questions, maintaining a simple task list, and quickly exposing mistakes—that helped the author transition from a technically‑focused newcomer to an effective, trusted team member.
The article presents a detailed, production‑focused harness for Claude Code that structures prompts, rules, skills, and external hooks to compensate for LLM shortcomings in Java microservice development, preventing hallucinations, concurrency bugs, and false completions while ensuring reliable code delivery.
The article explains that C’s lasting dominance stems from its extreme simplicity with only 32 keywords, low‑level hardware access, and its deep ties to Unix, which together created an ecosystem that outlasted newer languages despite C’s lack of modern features.
An experienced engineer weighs a Cainiao P6 offer, examining whether the role represents a platform upgrade or a career downgrade by evaluating platform fit, growth potential, opportunity cost, common pitfalls, and personal readiness for a two‑year capability rebuild.
Graphify turns scattered READMEs, design docs, code, and media into a searchable knowledge graph, letting AI programming assistants query relationships instead of repeatedly re‑scanning files, with step‑by‑step installation, command usage, and best‑practice guidance for teams.
Developers now feel AI shifting from code completion to autonomous task execution, making pure manual coding rapidly devalue while architecture, business understanding, and AI collaboration governance become the key skills to stay competitive.
Big tech companies use LeetCode algorithm tests as a standardized, quantifiable filter to gauge learning potential and problem‑solving skills, even though these tests do not reflect real engineering ability, leading to a paradox where strong algorithm performers may lack practical coding quality and vice versa.
The article analyzes how Alibaba Cloud’s CIO team used AI to triple front‑end output, double back‑end output, and cut defect rates while exposing the pitfalls of AI‑generated code metrics, advocating a shift from tool‑centric measures to business‑value‑driven engineering practices.
The article analyzes ThoughtWorks Technology Radar Vol. 34, highlighting how the rise of AI‑driven agents reshapes software engineering evaluation, introduces semantic diffusion and cognitive debt, and forces a return to classic practices while spotlighting newly adopted tools like Kafbat UI and Typer and warning about emerging anti‑patterns.
A veteran Java developer took a 5‑wan‑yuan retail project, relied on an end‑to‑end AI code generator for a month, then faced chaotic project structures, security flaws, and massive refactoring before discovering FeiSuan JavaAI's multi‑agent workflow that finally turned the disaster into a deliverable.
The article argues that an architect’s worth is measured by the business outcomes their systems enable rather than internal code elegance, citing AI‑generated code, the Taobao development story, and sales‑driven revenue as evidence that external value outweighs internal craftsmanship.
Superpowers adds a disciplined engineering framework to Claude Code by enforcing requirement clarification, test‑driven development, and isolated sub‑agent execution, turning AI‑generated code from flaky prototypes into traceable, maintainable software.
This article analyzes the progressive stages of AI‑driven software engineering—Prompt Engineering, Context Engineering, and Harness Engineering—illustrating how each addresses specific challenges, presenting real‑world experiments from OpenAI and Anthropic, and outlining a roadmap for engineers to master the new paradigm.
AI agentsLarge Language ModelsRetrieval-Augmented Generation
At QECon Shenzhen 2026, Xiaohongshu's tech team will present five technical talks that showcase how AI agents are applied to architecture risk analysis, change automation, large‑model load‑testing data construction, end‑to‑end testing, and client‑side performance, illustrating concrete engineering solutions and measurable productivity gains.
Anthropic’s Code w/ Claude developer conference revealed three major upgrades—a stronger foundation model, the Claude Platform’s multi‑agent orchestration, and the Claude Code desktop client—showcasing real‑world cases where 50 k lines of Scala were rewritten in four days and a 20‑day approval process was halved, while API usage jumped 17‑fold and weekly developer time on Claude rose to 20 hours.
The article explains how turning vague, experience‑based software tasks into measurable, structured processes enables AI to run autonomous improvement loops, creating a self‑reinforcing flywheel that boosts productivity while highlighting the necessary engineering infrastructure and real‑world constraints.
The article argues that many senior developers only repeat the same one‑year‑old skills, showing that true experience requires deeper problem‑solving, trade‑off thinking, and the ability to eliminate issues rather than merely execute them.
Programmers often wonder whether to stay on the technical track or move into management; the article explains that both routes involve hidden challenges, require influence, and the right choice depends on personal preferences for solving technical problems versus people problems and where one finds fulfillment.
The Unix V3 init(VII) manual famously declared “BUGS none possible,” a bold claim rooted in its tiny codebase, fixed hardware, tiny user base, and single‑author maintenance, a confidence that vanished by Unix V4 as complexity grew, illustrating the evolution from handcrafted init to modern systemd.
The article analyzes why AI coding assistants often stray from intended requirements, exposing a core judgment deficit, and shows how a concise four‑line CLAUDE.md file—detailing assumptions, minimal code, scoped changes, and verifiable success criteria—can dramatically improve AI behavior, reduce over‑design, and lower review costs.
Peter Steinberger disclosed that his project consumed 603 billion tokens and cost over $1.3 million in a single month, with OpenAI covering the fee, sparking a debate about token‑driven AI development, automation pipelines built with Codex, and the sustainability of the token‑maxxing trend.
The article details Harness Engineering’s deterministic multi‑agent workflow that splits novel writing into seven staged phases, enforced by strict rule files and verification scripts, enabling eight specialized AI agents to collaboratively produce complete wuxia novels with consistent characters, martial arts systems, and quality guarantees.
AI orchestrationdeterministic workflowmulti-agent systems
The article analyzes how Claude Code can operate reliably in monorepos and large codebases by reorganizing the repository into an agent‑friendly environment, detailing the seven‑step agentic loop, the role of CLAUDE.md, LSP navigation, Subagents, and a three‑layer architecture that balances context, execution, and governance.
The article critically examines the rapid rise of AI coding frameworks such as OpenSpec, Superpowers, GStack, GSD, and Agent Skills, exposing their hidden cognitive and token costs, comparing their core philosophies, and offering a principled strategy for selecting the right tool based on task scale.
In the AI era, the premium skill shifts from writing code or building architectures to accurately defining the right problem, a capability that AI cannot replace and that dramatically amplifies the impact of subsequent AI‑driven solutions.
This guide walks developers through the open‑source addyosmani/agent‑skills repository, explains its seven essential slash commands, shows how to install them via plugin or manual copy, demonstrates a complete AI‑assisted development loop, and compares the workflow with ECC agents.
In just six days, Anthropic's Claude AI translated roughly one million lines of Bun from Zig to Rust, preserving the original architecture, achieving 99.8% test pass rate, reducing binary size, and sparking debate over unsafe code usage and the broader impact of AI‑powered large‑scale code migrations.
The article analyses how AI‑assisted coding turns software projects into black‑boxes, explains why responsibility shifts from code authors to managers, and proposes a four‑layer control framework—requirements, architecture, implementation, and release—to keep AI output reliable, auditable, and safe.
The article explains why technical debt accumulates through small, ignored code issues, contrasts large refactor projects with daily "pay‑as‑you‑go" fixes, and offers concrete habits, checklists, and AI‑aware strategies for tech leaders to continuously improve code quality.
The article analyzes how AI programming assistants, while boosting productivity, are eroding developers' fundamental skills, citing personal anecdotes, industry surveys, and reports that reveal rising reliance on AI, increased technical debt, declining trust in AI‑generated code, and potential long‑term economic costs.
In the AI‑driven era, legendary programmers Eric S. Raymond and Uncle Bob argue that hand‑coding is fading, proposing two new criteria—AI’s ability to generate quality code and human readability—that make Go’s simplicity and Rust’s safety the preferred languages over traditional C, Java, and Python.
The article examines the pitfalls of "Vibe Coding"—quick AI‑generated code that skips testing and security—introduces the disciplined "Spec Coding" approach, and details how Addy Osmani’s open‑source agent‑skills project adds engineering rigor to AI coding through reusable skills, slash commands, and multi‑agent reviews.
The article analyzes how AI coding tools boost delivery speed yet erode maintainability, explaining that the root cause is the mismatch between traditional deterministic software engineering and the inherent non‑determinism of large language models, and proposes a structured engineering framework to mitigate the risks.
The article explains how Spec‑Driven Development (SDD) transforms AI‑generated code from risky demos into production‑ready features by defining executable specifications, enforcing review, injecting context, and automating verification, illustrated with a concrete order‑export example.
The article traces the evolution of the "Harness" concept from traditional test harnesses to modern AI agent engineering, explains the Planner‑Generator‑Evaluator architecture, evaluates its trade‑offs, and argues that Harness Engineering is a transitional technique rather than mere hype.
AI agentsPlanner Generator Evaluatorharness engineering
By experimenting with OpenAI’s /goal feature, the author shows how to turn ad‑hoc AI prompts into a structured, long‑running loop that records progress in Git, README and test artifacts, enabling agents to handle complex engineering tasks across multiple sessions with clear checkpoints and human‑in‑the‑loop control.
The article explores how software engineering research is shifting from human-centered to agent-centered development (Harness Engineering), identifying key research questions around software complexity characterization, machine-readable knowledge representation, agent team collaboration, and adapting traditional SE theories, while advising against investing in generic agent frameworks already dominated by large companies.
The article explains that the classic 800‑page software engineering textbook is not a list of methods to memorize but a decision‑making coordinate system that guides readers through process, requirements, architecture, testing, and evolution, helping them understand why and how to apply each practice in real projects.
A new benchmark called ProgramBench challenges top‑tier LLMs to rebuild 200 real‑world software projects from scratch, revealing that GPT‑5.4, Claude Opus, and Gemini all achieve a 0% full‑pass score while exposing design flaws, language‑choice biases, and rampant cheating when network access is allowed.
AI code generationLarge Language ModelsProgramBench
Tracking 200 senior Spring Boot positions in the US over 12 weeks, the author discovered that half disappeared as companies shift from pure CRUD roles to AI‑assisted system engineering, revealing a rapid transformation in backend engineer demand and required skill sets.
The article shows that adding redundant context to AI agents like Claude harms efficiency: each extra 50 lines dilutes attention, lowers task success by about 3 % and inflates token usage by roughly 20 %, because the model’s instruction budget is capped at 150‑200 tokens, so context files must be concise and focused on non‑derivable information.
Many developers learn dozens of design patterns but still end up with fragile, hard‑to‑maintain code; the article explains that the real key is to identify system problems first and apply a disciplined engineering decision method, illustrated with concrete Factory, Builder, Strategy, Template, Decorator, Adapter, Observer and Mediator examples.