Arc - Coaching for the Long Run

• 

• 

  Arc's Basecamp - What are you supposed to do today

• 

  Basecamp summary - How am I showing up today and what is the summary for the week?

• 

  Weekly Arc - What is this week's plan, catered to my real life

• 

  Your Trajectory - Where are you headed?

• 

  Coaching is there when you need it, and in the background when you don't, powered by AI

• 

  Feedback from Coach on a recent run and ultimately, what should I do next?

Inspiration

Arc started with a problem I knew personally: trying to return to consistent running after injuries, missed weeks, changing goals, and normal life interruptions. I have a family with young children, a busy job, and an on again off again training cycle.

Most fitness apps are good at recording what happened or handing someone a static training plan. They become less useful when the plan stops fitting. They do not always remember why a workout changed, whether pain is current or historical, how the athlete responded to the last session, or whether today’s recommendation still makes sense.

I wanted something that felt less like a calendar of workouts and more like an actual coaching relationship—one that could maintain context over time, adapt without overreacting, and answer a simple question clearly:

What should I do today, and why? That idea became Arc: an AI running coach focused on continuity, explainability, and helping people build consistency for the long run.

What it does

Arc is a functioning beta of an AI running coach designed to help an athlete understand what to do, why it fits, and how the plan should respond when life does not go perfectly.

A user can:

• Create an account and complete coach-led onboarding
• Add a race goal or begin with a general consistency goal
• Review a proposed first week before anything is added to the plan
• Approve the proposal or request changes
• Receive daily training guidance with an explanation, guardrail, and win condition
• Receive a personalized training plan that takes into account past and current activities and consistency, not from a 0 base plan
• Log or import completed activities
• Add post-run context about effort, pain, interruptions, or how the session felt
• Review observations and confirm whether Arc has identified a meaningful pattern
• Carry that context into future coaching and weekly planning

The Coach remains one continuous presence across onboarding, Today, Plan, post-run reviews, Weekly Handoff, and Trajectory. It is not a separate chatbot disconnected from the rest of the application.

Underneath the experience, Arc maintains server-backed planning and journey state. Drafts, approvals, coaching context, and progress do not disappear simply because the user changes screens, refreshes the browser, or returns later.

Arc also combines AI interpretation with deterministic safeguards. GPT-5.6 can explain, personalize, and reason about the athlete’s situation, while structured validation prevents unsupported claims, silent plan changes, stale pain context, and recommendations that exceed the information Arc actually has.

The goal is not for Arc to sound confident all the time. The goal is for it to be useful, grounded, and honest about what it knows.

How I built it

Let me be very clear on one thing: I am a finance manager, not a software engineer, and I began Arc with very little practical coding experience. I knew basic SQL from my work experience and beyond that enjoyed playing videos games. I didn't have even the slightest idea of how things are built with code.

Because of that, GPT-5.6 became both my product and technical thinking partner. It started as an analyst and moved quickly to a collaborator. It actively helped me turn a general coaching philosophy into concrete product capabilities, user journeys, state contracts, safety rules, acceptance criteria, implementation plans, and test scenarios.

It also challenged vague ideas. Throughout the project, I repeatedly had to distinguish between something that merely sounded impressive and something that would actually build trust with an athlete.

Codex worked directly in the repository. It helped:

• Audit existing frontend and backend behavior
• Trace bugs across multiple parts of the application
• Implement new features
• Create and update database migrations
• Write automated tests
• Review failures and regressions
• Inspect authentication and current-user isolation
• Validate each development pass before changes were committed
• Prepare features for deployment and controlled beta testing

The application was not generated from one large prompt. It grew through a repeated collaboration:

Define the user problem -> inspect the existing system -> establish constraints -> implement -> test -> review the actual behavior -> refine

GPT-5.6 helped me determine what the product should do and why. Codex helped translate those decisions into working software and verify that the implementation matched the intended behavior.

That loop allowed Arc to become much more coherent than I could have built by treating AI as a code generator alone.

Challenges I ran into

The hardest problems were not generating screens or writing coaching language. They were preserving trust and continuity across Arc.

A proposed plan must not silently become an approved plan. A request for changes must revise the same proposal rather than unexpectedly creating a different one. Pain context must be interpreted with the correct timing. A note about an old injury should not automatically be treated as an active problem today.

Coach explanations also need to be grounded in the current user’s actual data. Arc should not claim that training volume increased, that a pattern exists, or that a workout was completed unless the underlying evidence supports it.

Continuity created another set of challenges. A plan draft should survive navigation, browser refreshes, and login without regenerating. The Coach should understand which page the athlete is viewing while still maintaining the broader coaching relationship. Onboarding, daily guidance, activity reviews, and weekly planning must all operate on one coherent version of the athlete’s context.

The system also has to fail conservatively. When AI output violates a product rule, contains unsupported precision, or recommends something inconsistent with the available context, Arc must repair it, fall back to a safer response, or avoid making the change.

Solving these problems required more than adding prompts. It required clear state ownership, lifecycle rules, current-user scoping, migrations, validation, automated tests, and rollback planning.

OpenAI Build Week scope

Arc was already in development before OpenAI Build Week as an early, functioning beta. During the July 13–21, 2026 submission period, I used GPT-5.6 and Codex to meaningfully extend the product.

The Build Week work included:

• Completing the Continuous Coach Presence capability so the same Coach identity and context carry across onboarding, Today, planning, reviews, and other product transitions
• Implementing and validating the first-visit journey through plan proposal, revision, explicit approval, and the canonical Basecamp handoff
• Building a safe fresh-user fixture and testing authenticated state isolation, return continuity, and mobile behavior
• Hardening hosted operations, identity handling, backups, rollback readiness, and judge-access testing
• Expanding automated validation around onboarding state, plan approval, current-user isolation, and Coach continuity

The underlying Arc application and portions of its planning, activity, onboarding, and observation foundations existed before Build Week. The repository’s dated commit history and Codex session records distinguish that earlier foundation from the work completed during the submission period.

Accomplishments that we're proud of

I am proud that Arc has moved from an idea I could barely describe into a hosted, functioning application that I can use and test.

Some of the accomplishments that matter most to me are:

• Building an end-to-end experience that includes authentication, onboarding, initial plan generation, explicit plan approval, daily guidance, activity review, observations, and longer-term trajectory
• Creating one continuous Coach presence instead of placing a disconnected chatbot beside the product
• Preserving a coherent plan draft and coaching context across different parts of the application
• Making plan approval explicit so that AI-generated suggestions never silently change the athlete’s schedule
• Combining GPT-5.6 reasoning with deterministic safeguards and structured validation
• Building an observation layer that can identify a possible pattern, ask the athlete whether it fits, and use confirmed information in later coaching
• Creating automated tests around planning state, safety behavior, authentication, current-user isolation, activity evidence, and coaching continuity
• Deploying Arc into a controlled hosted environment with authentication, persistent data, health checks, backups, and rollback procedures
• Learning enough about software development to make informed product and technical decisions despite beginning with very little coding experience

The accomplishment I am most proud of is not any individual feature. It is that the product increasingly behaves like one connected coaching system rather than a collection of AI-generated screens.

What we learned

Building Arc changed how I think about both software development and AI-assisted creation.

I learned that AI provides the most leverage when the human is clear about the problem, the experience, and the standards the product must meet. A vague prompt may produce code quickly, but it does not automatically produce a coherent or trustworthy product.

I also learned that AI does not remove the need for product judgment. It increases the importance of it. Someone still has to decide what should happen, what should never happen, what uncertainty should look like, and which tradeoffs are acceptable.

Many of the most important improvements came from restraint:

• Do not regenerate a plan unless there is a reason
• Do not apply a proposal without approval
• Do not present an assumption as a fact
• Do not treat every data point as a meaningful pattern
• Do not overwhelm the athlete with every possible insight
• Do not let confident language hide weak evidence

I learned to think in terms of states, contracts, migrations, failure paths, and tests.

I also learned that tests can express my intedend product values. A test confirming that an unapproved draft cannot alter the plan is not only checking code, it is protecting user trust.

Most importantly, Arc showed me that someone without a traditional software background can build a serious product with AI, provided they are willing to stay deeply involved in the decisions, review the work critically, and keep refining the result. I have already taken many of these lessons to my finance team and have started coaching on best practices to upskill and build useful tools for our leadership team.

What's next for Arc - Coaching for the Long Run

The immediate next step is a small, controlled beta with real users.

That beta will focus on whether Arc can help someone build a durable coaching relationship over their first several weeks, not just whether they can complete onboarding or generate a plan.

The next areas of work include:

• Improving the progressive learning experience across a user’s first four weeks
• Expanding support for importing real activity history
• Deepening Weekly Handoff and plan-adjustment continuity
• Improving how Arc explains the evidence behind its recommendations
• Continuing to mature the observation layer without creating noise or false patterns
• Strengthening mobile usability and app-like navigation
• Expanding testing, monitoring, account recovery, and founder-independent operations
• Learning from real athlete behavior before expanding the product more broadly

Longer term, I want Arc to become more personal as it earns context. It should begin simply, learn from what the athlete does and says, and reveal deeper coaching only when the available evidence supports it.

The goal is not to create an AI that produces the most workouts or the most analysis.

The goal is to create a coach that helps someone keep going.

Built With

• auth0
• codex
• docker
• github
• gpt-5.6
• openai
• python
• railway
• react
• sqlite
• typescript