AI just built an AI product in 10 Days: A practical guide to embracing AI-generated code

Six months after its public release in May 2025, Claude Code reached $1 billion in run-rate revenue. More interesting than the revenue figure is how developers at Anthropic are using it.

Claude Cowork: AI Building AI in 10 Days

The most striking demonstration of Claude Code’s capabilities came just days ago with the launch of Claude Cowork. This new tool is essentially “Claude Code for non-developers” – an AI agent that works within the Claude Desktop app to handle knowledge work tasks like organising files, creating expense reports, analysing documents, and managing data across applications.

What makes this newsworthy isn’t just what Cowork does, but how it was built. When asked on social media how much of Cowork was built using Claude Code, Boris Cherny’s response was simple: “All of it.” The entire product was developed in approximately 10 days, with 100% of the code written by Claude Code itself.

This represents a significant milestone: an AI coding tool successfully building a completely new AI product from conception to launch in under two weeks. Cowork wasn’t a simple script or prototype—it’s a production-ready feature now available to Claude Max subscribers, capable of autonomous task execution with access to files and applications on users’ computers.

Why This Is Significant

Claude Code operates differently from typical code completion tools. It works through a command-line interface and takes a more autonomous approach—understanding context, planning implementations, writing features, and iterating based on feedback rather than just suggesting the next line of code.

The fact that it successfully built an entirely new product autonomously suggests the tool has reached a level of reliability that goes beyond experimental use. This represents a practical shift in how code can be written at scale.

Practical Implications

When AI handles most of the code writing, the developer’s role shifts towards architectural decisions, code review, and strategic planning. According to Anthropic’s observations, this doesn’t necessarily reduce headcount—it changes where developers spend their time and can increase overall development velocity.

The Cowork example is particularly instructive: a small team identified a use case, architected the solution, and let AI handle the implementation—shipping a complete product in 10 days. This development velocity fundamentally changes what’s possible for product teams.

How to Embrace AI Coding in Your Organisation

If you’re considering integrating AI coding tools into your development workflow, here are practical steps based on what’s working in production environments:

Start with Well-Defined, Contained Projects

Don’t try to transform your entire development process overnight. Begin with specific use cases where AI coding tools can deliver immediate value. Good starting points include building internal tools, creating API integrations, writing test suites, or developing proof-of-concept applications. As your team builds confidence and understanding of the tool’s capabilities and limitations, you can expand to more critical systems.

The Cowork development approach offers a useful model: the team had a clear product vision, well-defined requirements, and an existing architecture pattern to build upon. This allowed AI to focus on implementation rather than ambiguous requirements.

Establish Clear Review Processes

AI-generated code still requires human oversight, but the review process looks different from traditional code review. Your team needs to focus on architectural soundness, security implications, and business logic correctness rather than syntax and formatting. Create checklists specific to AI-generated code that cover security vulnerabilities, edge cases, performance considerations, and maintainability.

Even though Cowork was 100% AI-written, it still went through review and testing processes before shipping. The difference is that reviews happen faster when you’re checking generated code rather than writing it from scratch.

Invest in Prompt Engineering Skills

The quality of AI-generated code depends heavily on how you communicate with the tool. Your developers need to learn how to write effective prompts that provide sufficient context, specify requirements clearly, and include relevant constraints. Provide training on how to break down complex requirements, reference existing code patterns, and iterate when the initial output isn’t quite right. Developers who master prompt engineering can be 5-10x more productive than those who treat AI tools as simple autocomplete.

Redefine Developer Roles and Expectations

As AI handles more implementation work, your team’s value shifts to higher-level thinking. Developers become more like architects and product engineers—spending time on system design, technology selection, performance optimisation, and ensuring code aligns with business objectives. This requires adjusting job descriptions, performance metrics, and career paths. Instead of measuring lines of code written, focus on features delivered, problems solved, and system improvements made.

The Cowork team’s role wasn’t writing TypeScript—it was making architectural decisions, defining requirements, reviewing output, and ensuring the product met quality standards. These skills don’t disappear when AI writes code; they become more important.

Build Internal Guidelines and Best Practices

Every organisation has different security requirements, coding standards, and architectural patterns. Create documentation that guides how AI tools should be used within your specific context. This includes which types of code can be AI-generated with minimal review, which require extensive human oversight, and which shouldn’t use AI at all (such as security-critical authentication logic). Update these guidelines regularly as you learn what works.

Monitor Code Quality and Technical Debt

AI can generate code quickly, but speed without quality creates problems. Implement automated testing, code quality metrics, and regular technical debt assessments. Track whether AI-generated code introduces more bugs or maintenance issues compared to human-written code. Monitor dependencies that AI tools introduce—sometimes they’ll pull in unnecessary libraries or use outdated approaches. The goal is to maintain or improve code quality while increasing velocity.

Plan for Knowledge Transfer and Documentation

When AI writes most of your code, institutional knowledge can become fragmented. Developers may understand what the code does, but not why certain architectural decisions were made. Emphasise documentation of design decisions, trade-offs considered, and business context. Use AI tools to help generate documentation but ensure humans review and refine it. This becomes increasingly important as codebases grow rapidly with AI assistance.

Address Security and Compliance Proactively

If you’re in regulated industries like financial services, healthcare, or government, AI-generated code requires additional scrutiny. Establish clear policies about data that can be shared with AI tools—many organisations run local or private instances to ensure sensitive information doesn’t leave their environment. Conduct security audits of AI-generated code, particularly for authentication, authorisation, data handling, and external integrations.

What This Means for Different Stakeholders

For development teams, this shift means focusing less on syntax and implementation details, and more on problem-solving, architecture, and code quality. The developers who adapt successfully will be those who can think strategically about systems and communicate effectively with AI tools.

For engineering managers, the challenge is restructuring workflows, adjusting expectations, and ensuring quality standards are maintained while velocity increases. When products can be built in 10 days instead of months, planning cycles and roadmaps need to adapt.

For business leaders, AI coding tools offer the potential to accelerate product development, reduce costs, and enable smaller teams to accomplish more. However, the benefits require investment in training, process changes, and potentially new tooling infrastructure.

For consultants and service providers, this represents both an opportunity and a responsibility. We can deliver solutions faster and more cost-effectively, but we need to ensure we’re solving the right problems and building maintainable systems. The value proposition shifts from “we can build this” to “we know what to build and how to architect it effectively.”

Looking Ahead

The organisations that will benefit most are those that approach this transition thoughtfully,  experimenting with AI tools, learning from results, adjusting processes, and gradually expanding usage as they build confidence. This isn’t about replacing developers; it’s about amplifying their capabilities and allowing them to focus on higher-value work.

The Claude Code and Cowork milestones show us that AI-generated code isn’t a future possibility—it’s current reality. Products are being built entirely by AI, shipping to production, and serving real users. The question isn’t whether to adopt these tools, but how to do so effectively within your organisation’s specific context and constraints.

Are you using agentic coding tools in your projects? I’d be interested to hear your experiences — what’s working and what challenges you’ve encountered.