I had nine days before my fantasy football draft and a simple idea: build an AI assistant that gives real-time draft recommendations. What I didn't have was much coding experience. What I did have was Claude Code and enough product management experience to know what good software should look like.
This is the story of building FantasyAgent over about three weeks in August, and what AI-assisted development feels like when you are learning to code alongside the AI.
The Challenge
The requirements seemed simple:
- Follow my draft in real time
- Rank the available players against my roster and my league's format
- Recommend a pick fast enough to use on the clock
- Keep working for the whole draft
The hard parts were less obvious: several APIs, live data, a web interface, and making all of it reliable. I knew what needed to be built. I had no idea how to build it.
Week 1: Sleeper and the Foundation
I started with Sleeper, a fantasy platform with a developer-friendly API. No OAuth, clear documentation, and immediate access. Claude Code and I had a working foundation on day one.
Claude suggested CrewAI for a multi-agent setup. Instead of one prompt doing everything, the assistant used five specialized agents that run in sequence:
- Draft Monitor: tracks picks as they happen
- Data Collector: pulls rankings and player data
- Player Analyst: compares the players still available
- Draft Strategist: weighs roster needs and the league format
- Draft Advisor: turns all of it into one recommendation
Splitting the work made the system much easier to debug. When a recommendation looked wrong, I could see which step went wrong.
The Player ID Problem
The first real problem was identifying players. Sleeper uses different player IDs than FantasyPros, where the rankings came from. Josh Allen the quarterback is "4984" in Sleeper and "17298" in FantasyPros. Worse, Sleeper also lists a guard named Josh Allen, and Jacksonville's Josh Hines-Allen used to go by Josh Allen too.
Claude Code built a mapping that matched players across the two systems by name, team, and position. We ended up with 11,389 mapped players, which let us combine data from both sources.
The Superflex Problem
My league is a superflex keeper league, where quarterbacks are worth far more than in a standard league. The FantasyPros API returned standard rankings by default, so the assistant kept undervaluing quarterbacks. The fix turned out to be one parameter: asking for "OP" (offensive player) rankings returns superflex values. We also had to filter out players other teams had kept, after it recommended one of them to me.
Making It Fast Enough
The first working version took 30 to 45 seconds per recommendation, which is useless on a draft clock. Cutting the player list from 200 to 100 and trimming the prompts got it to 15 to 20 seconds. More optimization, plus caching the rankings so they weren't fetched on every pick, got recommendations down to a few seconds.
Yahoo's OAuth Maze
Confident from the Sleeper progress, I tried adding Yahoo. This is where I learned the difference between a cooperative developer platform and a difficult one.
Yahoo requires OAuth 2.0. As a product manager I understood OAuth conceptually. I had never implemented it. By day seven I had a working token, and after the draft I built a Yahoo version with its own agents. I never got it working end to end. Between the app approval process, the documentation, and token handling, Yahoo took more time than any other part of the project and never paid off.
Context Loss Becomes a Problem
By the second week, Claude Code kept losing track of earlier work. Each session felt like onboarding a new developer who had never seen the codebase. So I started keeping documentation written for the AI:
- CLAUDE.md: project context and conventions that Claude reads at the start of every session
- ACTION_LOG.md: what we built and why
- ISSUE_LOG.md: what broke and how we fixed it
These files are what kept the project continuous from one session to the next.
Draft Day: August 14, 2025
On draft day the data broke. The FantasyPros integration wasn't running, some rankings were from 2024 instead of 2025, and a cached file was four days old. We fixed it the same day and checked the output against real comparisons, like Burrow vs. Hurts in superflex, before trusting it.
After that, it held up. It didn't crash or hang, and the recommendations made sense for my league. For something built in nine days by someone learning to code, I was happy with that.
After the Draft: Auction Mode
Once the draft was done, I added an auction mode for Sleeper. A second set of agents, covering budget, player value, roster construction, and bidding strategy, recommends a maximum bid for each nominated player. It uses value-based drafting (VBD), position scarcity, remaining budget, and roster needs.
What I Learned About AI-Assisted Development
Context Management Is Critical
The biggest challenge was keeping context across sessions, more than any technical problem. Claude Code can hold a lot of complexity during a session, but that knowledge is gone at the next one. The fix was treating documentation as infrastructure. Every decision, error, and lesson went into a file the next session would read.
Data Problems Beat Code Problems
Most of my worst moments came from data: wrong IDs, the wrong ranking format, last season's numbers, stale caches. The code was usually fine. The data feeding it was wrong.
Platform Politics Matter
No amount of AI help makes up for a difficult platform. Sleeper's open API let me move fast. Yahoo's OAuth and approval process ate days and never worked end to end. Choose your platforms carefully, especially when you are learning.
AI Amplifies Domain Expertise
Claude Code picked up fantasy concepts like VBD, positional scarcity, and roster construction quickly. My product background helped too. I focused on error handling, the user experience during a live draft, and reliability, and I didn't stop once the code merely ran.
Deadlines Accelerate Learning
A real deadline with real stakes forced decisions that side projects usually avoid. Every feature had to work under pressure on draft day, and that made the product better.
The Technical Stack
- Backend: Python and FastAPI
- AI: CrewAI agents running on Claude
- Data: Sleeper API for drafts, FantasyPros for rankings
- Frontend: Vue.js
- Hosting: ran locally during the draft. Early on I experimented with deploying to AWS Lambda and Amazon Bedrock AgentCore.
What Worked
- Generating boilerplate and standard implementations
- Debugging syntax and logic errors
- Learning domain concepts quickly
- Suggesting architecture, like the multi-agent setup
- API integrations, when the documentation was good
Where It Struggled
- Yahoo's OAuth and app approval process
- Keeping context across a long project
- Requirements I hadn't written down
- Telling environment problems apart from code problems
- Architecture trade-offs with incomplete information
What It Means for Product Managers
AI assistants don't remove the need to understand the technology, but they lower the barrier to building something that works. Product managers can now validate ideas with working prototypes instead of mockups, and the time from idea to something testable drops from months to weeks.
When implementation stops being the main bottleneck, the constraint shifts to deciding what to build and why.
The Code
FantasyAgent is open source on GitHub: github.com/adamrubinsky/FantasyAgent
The repository includes the Sleeper integration, both agent crews, the player mapping data, and the development logs. Use it for your own draft or as a reference for building similar tools.
Looking Forward
Three weeks with Claude Code taught me that AI-assisted development makes implementation accessible to domain experts who couldn't build working systems before. I think the teams that figure out how domain experts and AI work together will build a lot of useful software.
Building FantasyAgent showed me that the gap between having an idea and having a working system is smaller than it has ever been. AI will change how software gets built. The open question is whether you figure out the new process early or late.
What will you build when implementation is no longer the main bottleneck?
Built with Claude Code over about three weeks in August 2025. The code is open source for anyone who wants to build their own draft assistant.