Guia para apreder una skill

• 

  main screen of the Skill Sprint App

• 

  2nd screen where we define our learning goal

• 

  diagnostic questions of our current level

Inspiration

Artificial intelligence has made it easier than ever to access information and learn new skills. However, access to content does not automatically translate into real capability.

As a 56-year-old IT professional, I need to continuously update my knowledge, learn emerging technologies, and remain relevant in an industry that is changing rapidly because of AI. I realized that the real challenge is not finding another course. It is understanding what I already know, identifying my actual gaps, creating a realistic learning plan, and proving that I can apply what I have learned.

That personal need inspired SkillSprint: an evidence-based adaptive learning application designed to help professionals reskill and upskill through focused, executable learning sprints.

What it does

SkillSprint transforms a professional learning goal into a personalized and adaptive learning journey.

The user starts by defining:

• The skill they want to learn.
• Their professional objective.
• Their current level.
• Their weekly availability.
• Their preferred learning style.

SkillSprint then uses GPT-5.6 to generate a short diagnostic assessment. Based on the user’s answers, it identifies strengths, knowledge gaps, priority competencies, and an estimated level.

The application creates a structured learning route divided into practical sprints. Each sprint includes:

• A specific learning objective.
• Focused activities.
• A practical challenge.
• Expected evidence.
• A weighted evaluation rubric.

The user submits evidence such as explanations, code, commands, YAML, JSON, or technical configurations. GPT-5.6 evaluates the evidence against the rubric and identifies strengths and gaps.

The backend then independently recalculates the score, determines the mastery level, and applies a controlled adaptation decision:

• Continue to the next sprint.
• Repeat the current challenge.
• Insert a focused remediation sprint.

SkillSprint also explains what changed and why, allowing the user to understand how their performance influenced the next learning step.

How we built it

SkillSprint was built with:

• Next.js 16.
• React 19.
• TypeScript.
• OpenAI Responses API.
• GPT-5.6.
• Structured Outputs with strict JSON Schema.
• Zod for request and response validation.
• Codex for software development support.
• Node.js native test runner with TSX.
• Vercel-compatible Next.js Route Handlers.

The application uses four backend endpoints:

• POST /api/diagnostic-questions
• POST /api/learning-routes
• POST /api/evaluate-evidence
• GET /api/health

GPT-5.6 is responsible for generating diagnostic questions, analyzing answers, creating sprint-based routes, generating challenges and rubrics, and evaluating submitted evidence.

However, the model does not have final authority over scoring or route changes. The backend recalculates weighted scores, derives mastery levels using fixed thresholds, validates every decision, and applies adaptations through a deterministic engine.

Codex helped accelerate the implementation of the architecture, domain model, TypeScript contracts, API endpoints, structured prompts, validation schemas, security controls, automated tests, documentation, and iterative debugging.

The final stabilized version includes 87 automated tests covering domain invariants, API contracts, prompt-injection boundaries, evaluation normalization, adaptation rules, error handling, and OpenAI response processing.

Challenges we ran into

One of the main challenges was latency.

Generating a complete learning route with multiple sprints, activities, challenges, evidence requirements, and weighted rubrics initially exceeded the application’s 60-second timeout.

We addressed this by:

• Using low reasoning effort for route generation.
• Reducing unnecessary verbosity.
• Limiting the route to three or four focused sprints.
• Limiting each sprint to two or three activities.
• Reducing the maximum output token budget.
• Increasing the route-generation timeout to 120 seconds.
• Detecting incomplete OpenAI responses explicitly.
• Adding safe telemetry for duration and token usage.

Another challenge was designing a reliable adaptive system without giving the language model unrestricted control over the learning route.

We solved this by separating AI recommendations from backend authority. GPT-5.6 evaluates the evidence and identifies gaps, but the backend recalculates the score, determines mastery, selects the supported adaptation, and preserves route invariants.

Prompt injection was another important concern because user-submitted evidence may contain instructions intended to manipulate the evaluation. SkillSprint treats all evidence as untrusted content, separates it from system instructions, validates every model response, and restricts decisions to a closed set of supported actions.

Accomplishments that we're proud of

We are particularly proud that SkillSprint evolved from a simple roadmap generator into a complete adaptive learning workflow.

The application can now:

• Diagnose a learner’s current knowledge.
• Generate a personalized sprint-based route.
• Create practical challenges and evaluation rubrics.
• Evaluate real evidence of learning.
• Detect strengths and competency gaps.
• Apply deterministic adaptation rules.
• Insert focused remediation when required.
• Explain what changed and why.

We are also proud of the trust and safety architecture:

• The OpenAI API key remains server-side.
• User inputs and model outputs are validated with Zod.
• Structured Outputs enforce strict response contracts.
• Submitted evidence is treated as untrusted content.
• Scores and mastery levels are recalculated by the backend.
• Adaptive decisions are restricted to controlled actions.
• Logs exclude prompts, evidence, authorization headers, and secrets.
• Errors are presented through safe public error codes.

The stabilized implementation passes 87 automated tests, TypeScript validation, ESLint, and the production build.

What we learned

We learned that personalized learning and adaptive learning are not the same.

A personalized system creates an initial plan based on a user profile. An adaptive system must observe performance, evaluate evidence, identify gaps, and modify the next learning step.

We also learned that an AI-generated result should not automatically become an application decision. For systems that evaluate people or modify workflows, deterministic backend controls remain essential.

GPT-5.6 is highly effective at interpreting open-ended evidence, generating structured educational content, and producing detailed formative feedback. However, reliable product behavior requires strict schemas, validation, fixed scoring rules, controlled actions, safe error handling, and clear boundaries between model recommendations and application authority.

Finally, we learned that professionals do not necessarily need more content. They need a clear path from intention to action and from completed activities to demonstrated capability.

What’s next for SkillSprint

The current hackathon version proves the complete adaptive learning cycle, but several areas can be developed further.

The next steps include:

• Persistent user accounts and learning history.
• Competency maps for specific professional domains.
• Specialized rubrics reviewed by subject-matter experts.
• GitHub integration to evaluate repositories, commits, and pull requests.
• File and multimodal evidence submission.
• Spaced repetition and long-term skill-retention tracking.
• Mentor review and human validation.
• Corporate upskilling and reskilling programs.
• Team dashboards for competency-gap analysis.
• Integrations with learning management systems.
• Professional portfolios containing projects and demonstrated evidence.

The long-term vision is for SkillSprint to become an AI-assisted learning execution system that helps professionals convert learning goals into measurable and demonstrable capabilities.

Built With

• adaptive
• codex
• edtech
• generative
• gpt-5.6
• learning
• next.js
• node.js
• openai
• react
• typescript
• vercel
• zod