Session 9: From Prompt Engineering to Agentic Engineering
Date: February 6, 2026
Duration: 1 hour 23 minutes
Presenters: Troy Wu, Elon Zhao, Damien Li
Participants: 100+ attendees visible during the live session
Session Recording
📋 Overview
Session 9 followed the progression from writing precise prompts to building increasingly autonomous agent workflows. Troy Wu returned to the fundamentals of prompt engineering and showed how structured context, test-driven development, and short feedback loops can guide AI through production-oriented coding tasks. Elon Zhao then demonstrated a vibe-coded internal reference dashboard, illustrating how conversational development can quickly turn daily information needs into a working web application. Damien Li closed with an OpenClaw deep dive covering personal agents, Skills, sandboxing, security, codebase analysis, and the shift from informal vibe coding toward disciplined agentic engineering.
Across all three talks, the recurring message was that autonomy does not remove the need for engineering discipline. Clear requirements, executable tests, controlled environments, observable workflows, and human review remain the foundations for useful AI-assisted software.
🎯 Key Topics Covered
1. Back to Basics: Writing Better Prompts
Presented by: Troy Wu, IL Reference Data
Troy described prompt engineering as the practice of maximizing the certainty and usability of a model's output within a limited context window. The objective is to reduce unnecessary freedom while still giving the model enough information to solve the real problem.
A practical prompt structure:
| Element | Priority | Purpose |
|---|---|---|
| Role | Required | Establish the relevant expertise and point of view |
| Background | Required | Supply the domain and system context |
| Task | Required | State exactly what the model must do |
| Requirements | Recommended | Define the expected behavior and completion standard |
| Constraints | Recommended | Set boundaries for technology, scope, performance, and safety |
| Format | Optional | Specify how the answer or artifact should be presented |
| Examples | Optional | Demonstrate the expected pattern or quality bar |
The examples contrasted a broad request such as “build a to-do application” with a prompt that defined the role, React and Tailwind stack, component structure, validation behavior, persistence requirements, and output format. The more structured prompt gave the model a much smaller and more useful solution space.
2. Prompt-Driven Development with TDD
The production example focused on assembling a schema model hierarchy from Cluster Key database results. Instead of asking AI to infer the entire design, the prompt supplied the important classes and interfaces, prerequisite code, business requirements, processing steps, and explicit constraints.
Four layers of useful implementation context:
- Define the key classes and interfaces to guide the solution direction.
- Include related prerequisite code so the model focuses on relevant context.
- Describe functional and non-functional requirements clearly.
- Explain the intended implementation logic and data flow.
The development flow then moved through tests, implementation, debugging, and optimization:
- For refactoring, existing tests preserve business knowledge and help verify unchanged behavior.
- For new business logic, failing tests clarify boundary cases before implementation.
- Each failure exposes an unclear or omitted requirement that can be added to the next prompt.
- Small iterations keep the feedback loop understandable and reduce the cost of correction.
- Performance work should include measurable targets; the example improved repeated lookups from approximately
O(n × m)toO(n + m).
The resulting code and passing tests become verified context for the next development step, creating a more reliable cycle than one large generation request.
3. Agent Skills as Reusable Prompt Packages
Troy presented Agent Skills as a way to move successful instructions out of individual conversations and into reusable project assets.
| Concern | One-off prompt | Agent Skill |
|---|---|---|
| Repetition | Rewritten or copied for every task | Defined once and invoked when relevant |
| Context usage | Full instructions are injected up front | Detailed guidance can be loaded progressively |
| Consistency | Depends on each prompt | Uses a shared SOP, templates, and scripts |
| Reuse | Manual | Discoverable by an agent or explicit command |
| Maintenance | Multiple prompts must be updated | Update the skill package once |
The session also compared Skills with MCP-style remote integrations: use Skills for repeatable local knowledge and workflows, and reach for remote connectors when the task genuinely requires an external system. The demonstrated increase-column-length skill encoded a multi-step database change procedure so the agent could follow the same safeguards every time.
4. Vibe Coding for Daily Work Efficiency
Presented by: Elon Zhao
Elon demonstrated a locally running Reference Data Dashboard created through conversational coding. The application brought frequently used information into one WiseTech-styled portal, including search, quick-access cards, database shortcuts, recent activity, AI news, and a collection of GitHub repositories.
The live development loop used VS Code and a coding agent to add React and TypeScript pages, track a to-do list, apply visual styling, and integrate new repository cards. A Vite import-resolution error appeared during the demo, making an important point visible: rapid generation still requires developers to inspect errors, correct missing files or imports, and verify the running application.
Practical lessons from the demo:
- Start with a specific daily friction point rather than an abstract “build an app” request.
- Describe the intended users, information architecture, design language, and core interactions.
- Let the agent break the change into tracked tasks, then review progress incrementally.
- Run the application early so build and integration problems appear while the context is fresh.
- Treat the first generated version as a prototype to refine, not a finished product.
5. OpenClaw and the Personal Agent Model
Presented by: Damien Li
The OpenClaw section explored an agent that can work across local files, messages, cloud services, calendars, development tools, and reusable Skills. A Discord-driven example showed the agent creating a project workspace and coordinating a coding tool to build a responsive landing page.
This model moves AI from answering questions toward operating a persistent computer environment. It can accumulate context, invoke tools, and extend its own working procedures, but the additional autonomy also expands the operational and security risks.
Limitations discussed in the session:
- Large, poorly indexed context can make retrieval slow and token-intensive.
- Local and cloud sandboxes need inspection, recovery, and backup mechanisms.
- Broad filesystem or network access creates meaningful data-exposure risk.
- Destructive file operations require review, version control, and reliable rollback.
- Personal agents need durable memory without allowing stale or unsafe context to spread unchecked.
The recommendation was to isolate experimental agents, restrict network and internal-system access, use least-privilege credentials, and make important operations observable and recoverable.
6. From Vibe Coding to Agentic Engineering
The closing analysis distinguished informal vibe coding from agentic engineering: structured systems in which agents plan, implement, evaluate, review, and revise work while preserving state and exposing checkpoints for human approval.
Core capabilities:
- Planning: decompose a goal into explicit, reviewable work units.
- Tool calling: use files, terminals, browsers, APIs, and specialist agents deliberately.
- Evaluation: test outputs against acceptance criteria instead of relying on plausibility.
- Memory: preserve useful decisions and context across steps and sessions.
- Review: introduce approval, revision, and failure paths before consequential actions.
The session used DeepWiki and code repositories to inspect OpenClaw's architecture, then compared it with sandbox designs used by desktop agent products. The broader observation was that agent software is beginning to resemble an operating layer: it coordinates models, tools, data, permissions, and reusable Skills. That potential makes engineering controls more important, not less.
📊 Presentations & Materials
Session Recording
🎥 Watch the February 6, 2026 recording
Recording highlights:
- Prompt anatomy and a production-oriented implementation example
- Test-driven AI development, iterative debugging, and performance optimization
- Agent Skills for reusable procedures and progressive context loading
- Live construction and debugging of a Reference Data Dashboard
- OpenClaw setup, personal-agent capabilities, and operational limitations
- Sandbox architecture, security boundaries, and agentic engineering workflows
No standalone presentation files were supplied with the recording. The screenshots above were captured from the session for reference.
🔗 Featured Resources
Prompting and Agent Skills
- Use Agent Skills in VS Code - Guidance for reusable agent instructions and supporting resources
- Anthropic Skills repository - Examples of skill packages and documented workflows
OpenClaw and Agent Architecture
- OpenClaw - OpenClaw project website shown in the session
- OpenClaw on GitHub - Source repository used for architecture exploration
- OpenClaw on DeepWiki - Codebase-oriented architecture analysis
- NanoClaw - A smaller agent implementation referenced in the closing analysis
- Claude Cowork - Desktop agent product discussed in the sandbox comparison
Model Releases Discussed
- Introducing GPT-5.3-Codex - Release material referenced during the session
- Claude Opus 4.6 - Release material referenced during the session
🎮 Quiz Activity
No structured quiz activity or scored quiz was included in the supplied recording.
🏆 Quiz Results & Winners
| Status | Details |
|---|---|
| No ranking published | The recording did not include a scored quiz or winner announcement. |
🔑 Key Insights
- Prompt quality is an engineering input: role, context, requirements, constraints, and acceptance criteria directly shape the usefulness of generated work.
- Tests turn conversation into evidence: executable checks expose missing requirements and make iterative AI development safer.
- Skills preserve successful practice: reusable procedures reduce repeated prompting and improve consistency across people and projects.
- Vibe coding is strongest for focused prototypes: begin with a real workflow, run the result early, and keep a developer in the debugging loop.
- Autonomy increases the need for controls: persistent agents require sandboxing, least privilege, monitoring, backup, and rollback.
- Agentic engineering adds structure: planning, evaluation, memory, tool orchestration, and review transform ad hoc generation into a repeatable system.
📚 Further Learning
For Developers
- Rewrite one recurring coding request using the prompt structure from this session.
- Add failing tests and measurable performance targets before asking an agent to implement a complex change.
- Turn a repeated local procedure into a small Agent Skill with validation and recovery guidance.
For Teams
- Identify where agents may access sensitive files, credentials, networks, or internal services.
- Define human approval points for destructive or externally visible operations.
- Keep agent-generated changes in version control and exercise the rollback path before relying on it.
🙏 Acknowledgments
Special thanks to:
- Troy Wu for the practical prompt engineering and TDD workflow
- Elon Zhao for the live vibe coding and Reference Data Dashboard demonstration
- Damien Li for the OpenClaw and agentic engineering deep dive
- Aimee Li for hosting and facilitating the session
- All participants for the discussion and continued knowledge sharing
Structure the feedback loop
Give the agent focused context, ask for a small verifiable step, run the tests or application, and feed concrete evidence into the next iteration.
Treat personal agents as privileged software
An agent that can read files, use credentials, access the network, or run commands needs isolation, least-privilege permissions, observable actions, backups, and a tested recovery path.
Session 9 | February 6, 2026 | From Prompt Engineering to Agentic Engineering | Troy Wu, Elon Zhao, Damien Li