Vibe coding: uses and limits
Help people explore ideas with AI. Use a banking prototype to understand why live data and API permissions need security evidence.
Understand AI development
THE OPEN LEARNING LIBRARY
All lessons
Find the lesson that helps with your work. Filter by responsibility, level, or topic.
Search inside every lesson →Lessons found: 50
Models, context, and incorrect answers
Identify how missing information can cause an incorrect answer, even from a capable model.
Understand AI development
Assistants, agents, and permissions
Distinguish an answer from an action. Identify the tools and permissions that change the consequences of a mistake.
Understand AI development
Choose a useful first AI task
Select a small task with clear inputs, visible results, and limited consequences.
Understand AI development
Measure useful progress
Measure completed work, review effort, and rework. Do not use generated code volume as a measure of value.
Understand AI development
Choose a model with evidence
Compare models on representative tasks, acceptance criteria, cost, and the operating constraints of your team.
Understand AI development
Write a task brief for an agent
Describe the required behavior, constraints, and evidence before the agent changes code.
Build with intent
Give an agent useful repository context
Provide current instructions, relevant code, and working check commands without exposing unnecessary information.
Build with intent
Use tests as evidence
Choose checks that can reject the wrong behavior. Review generated tests as carefully as generated implementation.
Build with intent
Review AI-generated code
Inspect the actual change, its trust boundaries, and its evidence before you accept it.
Build with intent
Change an existing system safely
Preserve current contracts while you introduce a change. Account for old clients, data, and deployment order.
Build with intent
Debug with testable hypotheses
Use an agent to compare explanations and collect evidence. Avoid repeated changes without a verified cause.
Build with intent
Define where your data can go
Trace data through the development tool, model, logs, and deployed service. Verify the boundary before using confidential information.
Make risk visible
Limit an agent’s authority
Define allowed actions, resources, and conditions. Verify permissions outside the model and separate implementation from release.
Make risk visible
Treat retrieved content as untrusted input
Recognize instructions hidden in repository files and tool results. Keep retrieved information separate from authority to act.
Make risk visible
Verify what enters the release
Inspect dependencies, build inputs, and artifact provenance. Connect the reviewed source to the software that reaches production.
Make risk visible
Connect obligations to evidence
Separate legal applicability, technical controls, and proof of operation. Build a record that a responsible reviewer can inspect.
Make risk visible
Threat-model an AI development workflow
Map assets, trust boundaries, and possible failures. Select controls and tests for a specific development scenario.
Make risk visible
Connect the complete software lifecycle
Follow one feature from a user need to operation and feedback. Identify the decisions that code generation cannot settle by itself.
Develop and operate at enterprise scale
Keep requirements traceable as software changes
Connect a user outcome to decisions, acceptance criteria, implementation, and evidence. Update the connections when assumptions change.
Develop and operate at enterprise scale
Platform engineering for AI development
Give people and agents supported ways to create, change, and operate services. Treat the platform as a maintained product.
Develop and operate at enterprise scale
Define the infrastructure beyond a prototype
Assess identity, networks, data, recovery, and operation. Connect a generated deployment to the company’s actual infrastructure requirements.
Develop and operate at enterprise scale
Design software for a cloud native environment
Connect repeatable infrastructure, replaceable processes, durable state, and observable behavior. Assess cloud native design beyond container packaging.
Develop and operate at enterprise scale
Choose availability across zones and regions
Compare high availability, Multi-AZ, and multi-region designs. Trace the complete request path and test the failure each design must withstand.
Develop and operate at enterprise scale
Set and test RTO and RPO
Define acceptable interruption and data loss. Compare recovery strategies and measure a complete recovery exercise against business requirements.
Develop and operate at enterprise scale
Coordinate AI development across teams
Manage shared contracts, review capacity, and change ownership. Measure the delivery system when many teams generate changes.
Develop and operate at enterprise scale
Make a release decision with evidence
Check the version, target, remaining risk, and recovery method. Separate merge, deployment, and user exposure when the system requires it.
Develop and operate at enterprise scale
Measure the delivery system
Combine delivery flow, instability, service outcomes, and effort. Use explicit definitions when evaluating AI’s effect.
Develop and operate at enterprise scale
Own the service after deployment
Define useful service signals, incident decisions, recovery, and maintenance. Keep operational responsibility visible after code generation ends.
Operate and improve
Maintain software throughout its useful life
Prioritize vulnerabilities, upgrades, configuration drift, and retirement. Follow a maintenance finding through to a verified production correction.
Operate and improve
Keep finding and fixing vulnerabilities
Build a continuous process from vulnerability detection to verified production remediation. Understand the maintenance gap a successful prototype can hide.
Operate and improve
Observe the service and its users
Connect metrics, logs, and traces to service objectives. Design alerts, data boundaries, and checks for missing telemetry.
Operate and improve
Manage an incident from detection to recovery
Coordinate responders, contain impact, communicate uncertainty, and verify recovery. Convert the incident into owned improvements.
Operate and improve
Connect delivery to the SOC and SIRT
Define security monitoring, incident handoff, evidence preservation, and recovery responsibilities. Keep security response connected to the software lifecycle.
Operate and improve
Set safe boundaries for self-healing
Automate known recovery actions with explicit authority, verification, and stop conditions. Separate runtime recovery from changing software.
Operate and improve
Close the loop with verified improvement
Turn production evidence into requirements, tests, controlled changes, and measured outcomes. Define what self-improving software can responsibly mean.
Operate and improve
Compare responsibilities before products
Compare an assistant, an internal delivery platform, and a software factory. Identify which work each option performs and which responsibilities remain.
Choose your operating model
Compare complete operating costs
Include setup, retained work, runtime, integration, and change. Test assumptions instead of treating a single estimate as a forecast.
Choose your operating model
Ask a supplier for evidence
Turn supplier claims into testable questions. Check scope, configuration, contractual terms, and the responsibilities your organization retains.
Choose your operating model
Verify an exit before you depend on a service
Separate source-code ownership from operational portability. Test exports, independent builds, infrastructure access, and the evidence needed for a transition.
Choose your operating model
Plan adoption with explicit responsibilities
Choose a bounded first service, define success and stop conditions, and assign the work that remains with your team.
Choose your operating model
Write a decision you can review later
Record the problem, alternatives, evidence, accepted limits, and review triggers. Make a build-versus-buy decision understandable after the meeting.
Choose your operating model
Start a new product in Taiga
Prepare a bounded product, establish its context, and connect planning to your actual repository and environments.
Put Taiga to work
Bring an existing codebase into Taiga
Review what Taiga derives from a repository. Separate current behavior from intended behavior and select the right response to an inaccurate document.
Put Taiga to work
Review Discovery as a connected document set
Trace a requirement through the specification, architecture, data flow, and security documents. Handle revisions before planning depends on stale assumptions.
Put Taiga to work
Turn an outcome into an initiative
Write intent that can become reviewable work. Inspect scope and dependencies before placing an initiative in the execution queue.
Put Taiga to work
Choose where Taiga waits for a decision
Separate plan approval, build execution, merge permission, and deployment. Configure autonomy around the decisions your organization must retain.
Put Taiga to work
Review a Taiga delivery with evidence
Connect the initiative, plan, run, diff, and checks. Verify the current change before accepting a merge or release decision.
Put Taiga to work
Resolve a Needs you interruption
Diagnose why an initiative stopped. Choose continuation, replanning, restart, or a human setup action without losing the decision context.
Put Taiga to work
Enable Taiga with a complete responsibility model
Connect business ownership, policies, platform boundaries, delivery controls, and ongoing operation before expanding use across products.
Put Taiga to work
No lessons match these filters. Try a broader topic.