How I Let Users Build Their Own Features with AI Agents — Without Them Even Knowing
Most product teams drown in feature requests while struggling with development bandwidth. What if your users could implement their own features through your app interface - with AI agents handling the coding while you sleep? See how connecting Warp's Oz cloud coding agent creates pull requests from simple user requests.
The Feature Request Problem Every Developer Knows
Every product team faces the same painful cycle: users request features through your app, those requests pile up in your backlog, and development bandwidth means most never get implemented. The AI tattoo app in this example was making $280/month in recurring revenue but struggling with exactly this bottleneck.
The traditional approach - manually evaluating each request and implementing when time allows - leaves users waiting and valuable improvements undeployed. Even with local AI coding assistants, running multiple agents bogs down your machine and requires constant oversight.
The breakthrough: By connecting user inputs directly to Warp's Oz cloud coding agents, feature requests automatically become pull requests - evaluated and implemented without developer intervention, while maintaining code review safeguards.
How Warp's Oz Cloud Agent Solves Local AI Limitations
Local AI coding assistants like Warp, Codex or Claude quickly max out your machine's resources when running multiple agents simultaneously. The Oz platform moves this workload to the cloud with several key advantages:
- Isolated environments for each agent with dedicated resources
- Parallel execution of multiple agents without local performance hits
- Multiple trigger options - CLI, Slack, GitHub actions, webhooks, or direct SDK integration
- Centralized management through Warp's agent panel
This architecture means your application can initiate coding agents in response to user actions without any local resource constraints. At 3:20 in the video, you can see how effortlessly new cloud agents spin up compared to local execution.
Real-World Implementation in an AI Tattoo App
The Inky Go AI tattoo application already had users submitting feature requests through an in-app form. Originally, these just generated Slack notifications for manual follow-up - meaning most requests went unimplemented due to time constraints.
By connecting this existing feature request flow to Oz agents, the app now:
- Accepts user requests through the same interface
- Triggers a cloud agent via the Oz SDK
- Has the agent evaluate the request's feasibility
- Automatically implements approved features via pull request
Users continue interacting with the same simple form, unaware they're actually initiating sophisticated AI development workflows behind the scenes.
Setting Up the Oz Environment
The implementation begins by creating a dedicated Oz environment tied to your GitHub repository (shown at 5:45 in the video). This environment specifies:
- The Docker base image for the agent's container
- Repository access permissions
- Setup commands (like
npm install) - Any required environment variables
The environment only needs setup once and can then be reused for all subsequent agent executions. Warp's interface makes this configuration straightforward, with intelligent defaults for common project types.
Pro Tip: Use oz environment list to retrieve your environment ID after creation - you'll need this for the SDK integration.
Connecting the Oz SDK to Feature Requests
The magic happens when connecting your application's feature request endpoint to the Oz SDK (implemented at 9:20). The integration requires just three key components:
- Install the Oz Agent SDK (
npm install oz-agent-sdk) - Initialize the client with your Warp API key
- Trigger agents when requests are received
The actual implementation is remarkably concise - about 15 lines of code that:
- Formats the user's request into an agent prompt
- Specifies the environment and model to use
- Sets guardrails for the agent's behavior
- Handles the response (typically just logging completion)
This lightweight integration means you can add AI-powered feature implementation to existing apps with minimal code changes.
Live Demo: Two Features Implemented in Minutes
The most compelling part comes at 12:30 when the video shows real feature requests being implemented live:
- Prompt Pinning: A user requested the ability to pin favorite prompts to the top of their history list
- Camera Grid: Another user asked for a toggleable grid overlay in the camera view
Both requests triggered separate Oz agents that:
- Evaluated the technical feasibility
- Implemented the features in isolated branches
- Opened proper pull requests
- Waited for human review before merging
The entire process - from user request to testable implementation - took under 10 minutes per feature, with both running simultaneously in the cloud.
Beyond Feature Requests: Other Oz Use Cases
While automated feature implementation is transformative, Oz agents can handle many other development tasks:
Schedule regular maintenance: Set up weekly agents to clean up tech debt, update documentation, or refactor problematic code sections.
- Automated issue triage: Have agents analyze new GitHub issues, label them, and attempt straightforward fixes
- Error monitoring: Connect Sentry or other monitoring tools to trigger investigation agents when errors spike
- Code reviews: Run agents to pre-review pull requests before human eyes see them
The cloud-based architecture makes Oz ideal for continuous, automated development tasks that would otherwise consume precious engineering time.
Watch the Full Tutorial
See the complete implementation from start to finish, including how the Oz agent management panel provides visibility into all running agents (demonstrated at 6:20). The video shows every step from environment setup to live feature implementation.
Key Takeaways
Connecting user inputs directly to AI coding agents represents a paradigm shift in product development. No longer must feature requests languish in backlogs - they can become implemented pull requests within minutes, while maintaining proper code review safeguards.
In summary: Warp's Oz platform lets your users effectively build their own features through your existing app interfaces, with AI agents handling the implementation work in the cloud. The result? Happier users, faster iteration, and developers freed from routine coding tasks.
Frequently Asked Questions
Common questions about this topic
Oz is Warp's cloud-based AI coding agent platform that runs in isolated cloud environments instead of locally on your machine. It can be triggered via CLI, Slack, GitHub actions, webhooks, or directly from your application code using their SDK.
This architecture solves the key limitations of local AI coding assistants by eliminating resource constraints and enabling true parallel execution. Multiple agents can work simultaneously without taxing your development machine.
- Runs in Warp's cloud infrastructure, not locally
- Supports multiple parallel agent executions
- Integrates through multiple interfaces including direct SDK
- Central management through Warp's agent panel
The automation connects your app's existing feature request interface to Oz agents via Warp's SDK. When a user submits a request, the app triggers a cloud agent that evaluates and potentially implements the feature.
The agent clones your repo into an isolated cloud environment, evaluates the request's feasibility, implements the changes if appropriate, and opens a pull request - all without developer intervention. The entire workflow happens in Warp's cloud infrastructure.
- User submits request through normal app interface
- App triggers Oz agent via SDK
- Agent evaluates and implements in cloud environment
- Changes submitted via pull request for review
The system includes multiple safeguards to maintain code quality. First, the agent evaluates whether the request is technically feasible and reasonable before implementation. Second, all changes go through a pull request workflow that requires human review before merging to main.
This maintains developer oversight while automating the initial implementation work. You can also configure the agent's base prompt to set specific guidelines about code style, architecture patterns, and implementation approaches.
- Agents evaluate request feasibility first
- All changes go through pull request workflow
- Human review required before merging
- Base prompts enforce coding standards
Yes, one of Oz's key advantages is its ability to run multiple agents in parallel. Each agent operates in its own isolated cloud environment with dedicated resources, so they don't interfere with each other or your local machine.
In the demo, two separate feature requests triggered two agents working simultaneously - one adding a prompt pinning feature and another implementing a camera grid toggle. Both completed within minutes while running in parallel.
- Multiple agents can run simultaneously
- Each has isolated cloud environment
- No local resource contention
- Central management through Warp panel
The core implementation took less than 10 minutes: creating the Warp environment, installing the Oz SDK, and writing the trigger code that connects feature requests to agent initialization.
The speed comes from Warp's pre-built agent infrastructure and straightforward SDK integration. Most of the time is spent configuring the environment (connecting GitHub, setting up the container) rather than writing integration code.
- Environment setup: 5 minutes
- SDK installation: 1 minute
- Trigger implementation: 3-4 minutes
- Testing and refinement: variable
Oz agents are versatile tools for automating many development workflows. Common use cases include scheduled code maintenance, documentation updates, GitHub issue triage, and error monitoring integration.
The cloud-based architecture makes Oz ideal for continuous, automated tasks that would otherwise require developer attention. All agents are managed from Warp's centralized panel regardless of their specific purpose.
- Scheduled code cleanups and refactoring
- Automated documentation updates
- GitHub issue triage and labeling
- Sentry error monitoring and investigation
No - from the user perspective, they're simply submitting a feature request through a normal app interface. The Oz agent workflow happens entirely in the background.
Users see the implemented feature in a future update without any awareness of the automated development process. This creates a magical user experience where requests seem to implement themselves, while actually leveraging sophisticated AI workflows.
- Users interact with normal app interfaces
- No indication of automated implementation
- Seamless experience from request to feature
- Maintains user expectations and trust
GrowwStacks specializes in implementing AI agent workflows like the Oz integration demonstrated here. We can design, build and deploy custom automation systems that connect your user inputs to cloud-based AI agents.
Our team handles the entire integration - from environment setup to SDK implementation to testing and deployment - so you can focus on your product while AI handles the grunt work. We ensure the solution fits seamlessly into your existing workflows.
- Custom workflow design for your use case
- Complete Oz environment setup
- SDK integration with your application
- Testing and deployment support
Let Your Users Build Features While You Sleep
Feature backlogs cost you user satisfaction and competitive advantage every day they go unaddressed. With GrowwStacks' AI agent implementation, your app can automatically turn requests into pull requests overnight.