AI Agents Transform Business Operations: Selfish Club's 2-Month Agentic Project Journey

Core Takeaways

One person accomplished what previously required a full team through AI agent integration, cutting development time by over 50%
Non-developers successfully built production systems without writing a single line of code using Claude and AI agents
Three critical success factors: Understanding data structures before starting, creating comprehensive MD files for context, and breaking projects into versioned roadmaps
Real-world implementation proved that agentic workflows reduce repetitive tasks while maintaining consistency across team outputs
Marketing capabilities matter more than technical skills when building scalable AI-driven products in the modern era

What Defines "Agentic" in Practical Business Operations?

When Selfish Club embarked on their two-month "AX" (Agentic Transformation) project, the team discovered that "agentic" means far more than simply having AI plan something in a chat window. After extensive hands-on implementation, they developed their own operational definition: an agentic system is one where AI independently thinks, improves, and produces tangible results within a defined workflow, often enabling a single person to work as efficiently as an entire team.

For the Selfish Membership team specifically, this transformation wasn't about replacing developers or designers. Rather, it was about fundamentally restructuring how work flows through the organization. Before the AX project, the team had already succeeded through two previous operational eras. First came the no-code era, where platforms like Webflow allowed non-technical team members to quickly launch landing pages and membership pages without touching code. This approach prioritized speed and iteration, though each page required custom adjustments and significant time investment.

The team then evolved into the automation era, where tools like Zapier, Make, and N8N enabled them to build sophisticated workflow automations. Repetitive tasks—sending confirmations to users, triggering reminder messages, managing referral cascades—could now execute 24/7 without human intervention. They conducted 19 sharing sessions documenting how these automation methods transformed their operations. However, even with automation in place, certain bottlenecks remained. Node-by-node configuration still required manual effort. Page layouts still demanded custom tweaking. The team knew they could do better.

The breakthrough came when they recognized that Claude Code and advanced language models could handle what Webflow and automation tools couldn't: generating complete, production-ready code and system architectures from natural conversation. This insight led to the agentic era. Where previous approaches excelled at specific tasks, agentic systems could handle entire workflows from planning through deployment—all coordinated by AI that understands context, maintains consistency, and improves iteratively.

The Three Pillars of Successful Agentic Transformation

For organizations considering similar transformations, Selfish Club identified three measurable outcomes that define whether a team has truly become "agentic":

Pillar One: Individual Productivity Reaches Team-Level Output

The most concrete evidence of successful agentic implementation is when one person produces results that previously required collaborative team effort. In Selfish Club's case, their AX PM (referred to as "BB") single-handedly developed the entire admin system, detailed page infrastructure, database connections, and user-facing features over two months. This wasn't about working longer hours or cutting corners—it was about eliminating the friction between idea and execution.

Previously, even with automation tools, the workflow looked like this: a PM would conceptualize a feature, document it in Notion, schedule a meeting with technical team members, receive estimates, wait for development cycles, receive deliverables, provide feedback, and finally see deployment weeks later. Now, with agentic systems, a PM can discuss requirements with Claude Code in real-time, see visual previews immediately, make adjustments instantly, and have production-ready code within hours. For the detailed pages the team creates monthly for various programs (sharing sessions, workshops, challenges), this translated to pages with integrated payment systems, database connections, and responsive designs being created in just two days—a process that previously took two weeks.

Pillar Two: Non-Technical Team Members Drive Implementation

The second pillar of agentic success is that implementation barriers for non-technical staff essentially vanish. Vivian, who served as the primary PM for the AX project, had never written a line of code in her professional life. She came with 12 years of marketing and business operations experience from various startups—she understood workflows, user psychology, and operational efficiency, but not programming infrastructure.

Yet she successfully architected an entire platform migration, designed database structures, and implemented security protocols. When Claude Code suggested that she consider the "Brainstorming Companion Skill," she could evaluate technical recommendations based on business logic rather than technical merit. When infrastructure challenges emerged—like token usage spikes requiring image storage optimization—she could ask clarifying questions and implement solutions without needing to learn Cloudflare, Supabase, or database architecture from first principles.

This capability represents a fundamental shift. In traditional development environments, non-technical stakeholders hit hard ceilings when attempting to modify or expand systems. With agentic systems, questions like "Can we add a login feature?" or "Should we migrate from Webflow to a custom platform?" become straightforward conversations rather than complex technical proposals. The AI handles the "how," while humans provide the "what" and "why."

Pillar Three: Real-Time Synchronization Across Team Members and Roles

The third pillar addresses organizational scalability. As teams grow, onboarding new members becomes increasingly expensive. New developers need weeks to understand codebase architecture. New marketers need context about brand guidelines. New operations staff need explanations of workflow quirks accumulated over months. With agentic systems, this problem diminishes significantly.

Selfish Club implemented this through comprehensive Markdown (MD) files that Claude Code reads automatically at every session start. The Claude MD file contains the complete project structure, technology stack, current progress, and architectural decisions. The Agent MD file specifies constraints and safety guidelines. The Design MD file codifies brand colors, typography, and component standards. When a new team member joins and has conversations with Claude Code, the AI immediately understands the established context, tone, and constraints—even if the human is working with the system for the first time.

This synchronization created something unexpected: consistency without surveillance. If one person creates marketing copy and another person builds a landing page on different days, using different chat sessions, both outputs maintain the same brand voice, design language, and messaging hierarchy. The AI isn't importing stored brand guidelines; rather, it's internalized the team's identity from the context-rich MD files and decision logs. Team members experience real-time coordination without needing synchronous meetings or extensive documentation reviews.

The Two-Month Journey: From Planning to Production

Month One: Strategic Foundation and System Architecture

The AX project began not with development, but with extensive planning conversations in Claude Chat. Rather than jumping into Claude Code immediately, Vivian deliberately separated the planning and building phases. The reasoning was practical: without clarity on what needed to be built, development would meander. Without shared context across the team, different people would receive contradictory information. Without organized priorities, the project would expand infinitely.

She started by rambling into Claude Chat—verbally transcribing her thoughts using a voice-to-text tool called Timelaps. Rather than typing organized narratives, she spoke naturally: "I wish we had this feature... and also this one... though this seems more important... and we really need to handle security for this part." Timelaps transcribed and organized these rambling thoughts into coherent lists. Claude Chat then took those lists and created a comprehensive MD file structure.

This MD file became the North Star for the entire project. It documented not just what to build, but why each component mattered, which existing systems needed protection, and what patterns had been successful in the past. From this single MD file, Vivian requested two immediate outputs: a dashboard and a ** roadmap**. The dashboard would track all tasks needed to complete the project, visualized in HTML for clarity. The roadmap would show dependencies and sequence.

Claude Code generated this dashboard with 63 initial tasks. Within the first week, as actual building began and edge cases emerged, the task count grew to 139. Rather than seeing this as scope creep, Vivian recognized it as necessary discovery. She automated the dashboard to self-update whenever new tasks emerged from Claude Code's recommendations. This created a living document that showed not just planned work, but discovered work—all of it visible to every team member reviewing the project.

The team also established three distinct MD files rather than one monolithic file. Claude Code reads through its entire context document every time it starts a new task. If everything lived in one 50,000-word file, every task execution would consume tokens reading information irrelevant to that specific task. By separating Claude MD (overall architecture), Agent MD (constraints and safety), and Design MD (visual standards), the team reduced unnecessary token consumption by roughly 40% while maintaining perfect consistency.

Month Two: Development, Iteration, and Emergent Workflows

With the foundation established, month two focused on actual system building. Rather than sequential development phases, the team adopted an overlapping approach. While core infrastructure was being built, page templates were being designed. While database connections were being established, the admin panel was receiving interface polish.

One critical output of this phase was what Vivian called the Worklog skill—an automated system for recording daily progress, struggles, and learnings. Each day, after substantial work was completed, she would trigger the worklog command. The system would:

Summarize that day's accomplishments in plain language, avoiding technical jargon
Document struggles and learning moments in a structured format that highlighted decisions that could apply to future projects
Extract discussion points for team weekly reviews
Update Obsidian notes (a local markdown note system) automatically
Push records to GitHub simultaneously across multiple repositories

What seemed like administrative overhead proved transformational. The worklog created an institutional memory. When the same type of problem appeared twice, Vivian could reference her worklog to see exactly how she'd solved it previously. When she needed to explain her decision-making to executives or other team members, the worklog provided evidence-based narratives rather than reconstructed memories.

Moreover, these worklogs became content assets. Later, when creating sharing session materials and blog posts, instead of starting from blank pages, Vivian could ask Claude to "summarize weeks 1-5 of worklogs and extract the three biggest learnings." The accumulated decision logs—originally created for internal tracking—became external-facing educational content.

The actual technical outputs during month two included:

The Admin System: Built entirely with Claude Code, the admin system provided a unified interface for managing all website content. Rather than technical team members needing to access Webflow directly or manipulate databases, any team member could log into the admin panel and manage detailed pages, toggle programs on/off, adjust copy, insert images, and configure payment flows. The admin system connected three external services seamlessly: Supabase (for data), Cloudflare (for image storage), and PortOne (for payment processing).

Detailed Page Templates: The team created a skill-based workflow for generating detailed pages. When triggered, this skill conducted an interview: "What type of program is this? What's your target audience? What's the core message?" Crucially, if the PM had meeting minutes from ideation sessions, they could paste them directly. The skill would analyze the natural language from those meetings, identify key messaging points, understand target audience needs from conversational context, and generate a draft page structure in text form.

Once the structure looked right through back-and-forth conversation, the system would generate complete HTML code. That HTML code was then pasted into the admin system, where final adjustments—image insertion, minor copy tweaks, color changes—could be made visually without touching code.

Custom Design Pages: Beyond templated pages, Selfish Club wanted to create distinctive landing pages for major initiatives. For these, Vivian used the "Brainstorming Companion Skill" from Claude's Superpowers package. This skill launched a local browser window where design decisions could be made visually and in real-time. Rather than the traditional workflow of description → designer mockups → feedback → developer implementation → revision cycles, the Brainstorming Companion allowed Vivian to have a conversation while viewing live design updates. "I'd prefer cream tones that are easier on the eyes" would instantly update the design palette. "This section should have parallax scrolling" would show immediately rather than after multiple iterations.

The result: a custom landing page with 11 sections, integrated payment processing, full mobile responsiveness, animated elements on scroll, and a data collection form connecting to their Supabase database—all completed in two days.

Critical Implementation Lessons: What to Avoid

Lily, the PM for the Selfish Membership program, identified two lessons she wished she'd known before starting the AX project. These are patterns that regularly trip up organizations attempting similar transformations:

Lesson One: Understanding Your Data Structure Is Non-Negotiable

Before beginning an agentic project, the organization must thoroughly understand how data currently flows through their systems. This means mapping not just what data exists, but where it's created, how it's used at each stage of workflows, and what transformations it undergoes.

For Selfish Club, this meant creating detailed diagrams showing what happens when someone applies for a sharing session: How is their application data captured? Where is it stored? What systems access it? When are confirmation messages sent? What data does that message reference? If they later want to access their application history on a "My Page," what data needs to be retrieved and in what format?

Without this foundational understanding, when you ask Claude to build an automation or design a page, the outputs will be technically functional but misaligned with your actual operations. The AI might design a perfectly logical data flow that conflicts with how your existing system actually works. You'll end up rebuilding things, wasting tokens, and creating frustration.

Lily's recommendation: Use visualization tools like Figma or Canva to create flowcharts of your current data paths. Document not just the happy path, but edge cases: What happens if someone applies twice? What if they forget their password? What if they want a refund? Once this is visually documented, you have something concrete to share with Claude that reduces misalignment dramatically.

Lesson Two: Strategic Scope Selection Prevents Project Abandonment

The second critical lesson: don't start an agentic project by randomly trying different applications or features. Many organizations with initial enthusiasm launch AI projects without clear goals, build some neat prototypes, then watch the projects stall when leaders struggle to see business impact.

Instead, Lily recommends starting with a "business impact framework": What are the three biggest operational pain points? Of those, which could be partially solved through agentic systems? Which of those solutions are actually feasible for your team to build? Rank those by impact and feasibility, then tackle them sequentially rather than simultaneously.

For Selfish Club, the identified high-impact, feasible starting point was detailed page automation. They created many different event pages throughout the year. Each time, they started from scratch. By creating a system where meeting minutes could become page structures, then structures could become HTML, then HTML could be deployed with minor tweaks, they created immediate, measurable value. Not only did page creation become faster, but the team could see exactly how the agentic system was improving their work.

Only after proving the concept with detailed pages did they expand to other domains: admin panels, CRM automation, custom design pages. This sequential approach meant each phase reinforced organizational confidence rather than creating the pattern of "we built something cool but don't actually use it."

The Tools and Infrastructure Stack

Understanding Selfish Club's technical setup illuminates practical choices when building agentic systems:

Core Development Environment

Claude Code: Primary tool for all system building, development, and infrastructure
Claude Chat: Planning, context-sharing across team, skill creation
Obsidian: Local markdown-based note system for worklogs and decision documentation, shared via GitHub
Timelaps: Voice-to-text transcription tool for converting spoken planning into organized notes

Database and Storage

Supabase: Primary database for structured data (user information, application records, membership details)
Cloudflare: Image and file storage (chosen to optimize token usage since image data causes high token consumption)
PortOne: Payment processing integration (connected to Toss Payments in Korea)
Vercel: Web server for hosting (free tier, sufficient for their current scale)

Collaboration and Synchronization

GitHub: Repository management for code and shared worklogs, enabling real-time team synchronization
Google Drive: File sharing for MD files and documentation
Notion: Team documentation, project tracking, and detailed benefit materials

Why This Stack?

Rather than viewing these tools as a prescribed checklist, Selfish Club made organic decisions. Cloudflare, for instance, emerged from conversation. During a planning session, Vivian noticed token usage spiking dramatically—an entire month's token budget consumed in a single day. She asked Claude for solutions. Claude suggested that image data stored inline was the culprit and recommended Cloudflare for separate image storage. Within the planning conversation, not through separate research, the infrastructure evolved to match actual constraints.

Similarly, Timelaps wasn't chosen after competitor analysis. Vivian simply needed a voice-to-text tool that organized rambling thoughts coherently. She found one that worked. The specific tools matter far less than their ability to reduce friction between human intention and technical execution.

Organizational Transformation: Beyond Technical Change

Perhaps the most significant outcome of the two-month AX project was how it changed the team's decision-making culture. When Vivian asked Claude Code, "What kind of person do you think I am?" after two months of intensive collaboration, Claude responded: "You're not someone who became a coder, but someone who found ways to use technology. You created structures where people produce results without needing to understand code."

This observation captured something important: agentic transformation isn't fundamentally about learning to code. It's about recognizing that the bottleneck has shifted from technical execution to strategic thinking. In previous eras, the limiting factor was whether developers existed to build features. Now, the limiting factor is whether leadership can think clearly about what should be built and why.

This shift explains why Selfish Club discovered that marketing capabilities become more strategically important in an agentic era than technical capabilities. When implementation becomes trivial—literally asking an AI to build something—the scarce resource is not developers but people who understand users, markets, and growth. The team moved from a structure where "someone needs to be a developer" to a structure where "someone needs to understand what customers need and why."

This also explains why Selfish Club shifted toward a "PM-centric organization where everyone is a PM." The traditional structure—developers, designers, marketers, operations staff working in separate silos—made sense when each role had significant implementation friction. Removing that friction meant the fundamental role became framing problems and decisions, not executing predetermined tasks.

Practical Implementation Framework for Your Organization

For organizations considering similar transformations, the framework Selfish Club validated through two months of intense iteration can be summarized:

Phase One: Foundation (Weeks 1-2)

Map your current data structures and workflows using visualization tools
Create your initial Claude MD file documenting the complete current state
Define business-impact goals for your agentic project
Select one high-impact, feasible starting domain (don't try everything simultaneously)

Phase Two: Planning and Context (Weeks 3-4)

Conduct planning conversations in Claude Chat using voice transcription tools if possible
Generate your complete project roadmap with versioning
Establish design and safety constraints in separate MD files
Identify and document patterns from your best previous work

Phase Three: Development with Documentation (Weeks 5-8+)

Move into Claude Code for actual system building
Implement automated logging systems for decision documentation (worklogs)
Create skills for repetitive processes in your domain
Use visual design collaboration tools (like Brainstorming Companion) for customer-facing interfaces
Plan regular team synchronization sessions around accumulated worklogs and decision logs

Phase Four: Expansion and Learning Extraction (Ongoing)

After validating your first use case, select the next high-impact domain
Extract learning from accumulated worklogs to inform new projects
Create shareable content from implementation experiences
Continuously refine your MD file context as organizational understanding deepens

The Hidden Challenge: Organizational Psychology

While the technical aspects of agentic transformation get most attention, Selfish Club discovered that organizational psychology is equally critical. Team members accustomed to certain workflows need permission to think differently. When implementation becomes frictionless, some team members experience anxiety about their role. If "anyone can build a website now," where does the specialist expertise exist?

Selfish Club's answer: specialization shifted from execution to judgment. Their former web designers didn't disappear from the organization; they evolved into "PMs who are good at design." Rather than designing and handing off designs to developers, they now understand product structures, user flows, and business impact. They make better strategic decisions about design because they understand infrastructure constraints and business goals more fully.

Similarly, developers haven't become obsolete in organizations embracing agentic systems. They've become specialized problem-solvers for unusual challenges. When Claude Code reaches its boundaries—perhaps when integration with legacy systems is required or when bespoke security protocols are needed—experienced developers can step in with deep infrastructure understanding. But they're no longer the bottleneck for standard work.

This organizational shift requires clear communication. Leaders need to explicitly state that agenticification is about multiplying human capability, not eliminating human roles. People need to see how their expertise becomes more valuable in an environment where implementation is handled by AI, because their judgment becomes more visible and impactful.

Metrics That Matter: Measuring Agentic Transformation Success

Selfish Club tracked several metrics that might inform other organizations:

Time-to-Market for New Initiatives: Before AX, launching a new program (sharing session, workshop, challenge) required custom detailed page creation, taking 1-2 weeks. After AX, detailed pages with payment integration and database connections emerge in 1-2 days. This 85-90% reduction in time-to-market directly accelerates revenue realization.

Token Efficiency Across Team Members: As the team optimized how they structured MD files, reduced unnecessary context reading, and created reusable skills, token consumption per completed feature decreased. An admin system that might have consumed 500,000 tokens through inefficient conversations now takes 150,000 tokens through better structuring.

Feature Expansion Without Team Scaling: Over two months, the team went from supporting a single membership platform to building custom landing pages, detailed page systems, admin interfaces, payment processing, and laying groundwork for AI consultant agents. This would normally require 2-3 new hires. Instead, one person drove it with AI collaboration.

Knowledge Retention and Transfer: By implementing mandatory worklogs and decision documentation, the team captured institutional knowledge that previously existed only in individual minds. This knowledge became transferable—new team members could reference six weeks of decision logs rather than waiting weeks for context to accumulate through osmosis.

Decision Quality Improvement: As decision logs accumulated, Vivian noticed her strategic thinking improved. Rather than debating the merits of competing approaches, she could reference her worklogs to see what had and hadn't worked before. This created a compounding learning curve where each decision informed subsequent decisions more intelligently.

Realistic Expectations: What Agentic Systems Can and Cannot Do

Throughout the sharing session, Selfish Club emphasized realistic expectations. Agentic systems are not magic. They don't eliminate the need for human judgment. They don't automatically align with business strategy if that strategy isn't clearly defined. They require substantial upfront investment in context and planning before they become efficient.

What agentic systems do accomplish:

Eliminate repetitive, mechanical work
Accelerate iteration cycles from weeks to days or hours
Make advanced technical capabilities accessible to non-technical team members
Ensure consistency across distributed teams and asynchronous work
Create institutional memory through decision documentation

What agentic systems do not accomplish:

They cannot replace strategic thinking about what to build or why
They cannot substitute for understanding your actual users and their problems
They cannot fix organizational dysfunction rooted in poor communication or unclear objectives
They cannot automatically generate novel business ideas or market insights
They cannot maintain systems or handle novel edge cases without human oversight

Selfish Club's success came from recognizing these boundaries. They didn't ask Claude to determine their strategy. They determined strategy through human conversation, then asked Claude to execute it. They didn't expect the admin system to function without occasional human adjustments and oversight. They built systems with human-in-the-loop oversight points where judgment is required.

The Emerging Question: What's Next?

By the conclusion of the two-month project, Selfish Club had completed Phase 1 of their agentic vision: detailed pages, admin systems, and basic automations. But they identified 22 additional opportunities for agent-driven features across their platform. Some of these include:

AI consultant agents that can understand member questions in natural language and provide immediate, personalized answers
Automated content curation that suggests relevant resources based on individual learning patterns
Predictive scheduling that recommends optimal times to offer programs based on historical conversion patterns
Personalized learning paths that adapt program recommendations based on individual progress and interests

Rather than pursuing all of these simultaneously, they're following the framework they developed: prioritizing by business impact, ensuring feasibility, and implementing sequentially. Version 1 accomplished the foundation. Version 2 will expand to core operations. Version 3 will tackle the innovative frontier.

This phased approach reflects a crucial insight: agentic transformation isn't a single project with a finish line. It's a new operating mode where technology increasingly handles routine execution while humans focus on judgment, strategy, and customer understanding. As capabilities expand, organizations revisit their work and ask, "What else could we do differently with these tools?"

Conclusion

The story of Selfish Club's two-month agentic project demonstrates that transformative change in how organizations work is possible without massive technical expertise, large engineering teams, or unlimited budgets. What's required is clarity about what you're trying to accomplish, willingness to invest upfront in documentation and context-setting, and commitment to learning from the process systematically.

The most surprising discovery from the project wasn't technological—it was that when implementation becomes trivial, everything else becomes more important. Business strategy matters more. Customer understanding matters more. Team communication matters more. The tools didn't create success; they revealed what actually matters about how organizations function.

For teams considering agentic transformation, the path forward is clear: start with understanding your current operations deeply, establish your strategic objectives explicitly, document your context thoroughly, then build incrementally while capturing learnings continuously. The future of work isn't about finding the right AI system—it's about building organizational practices where humans and AI collaborate in complementary ways, each handling what they handle best.

원문출처: [이기적공유회] 셀피쉬클럽의 2개월,격동의 에이전틱 프로젝트

powered by osmu.app

AI Agents Transform Business Operations: Selfish Club's 2-Month AX Project Case Study