AWS Builder Center
SkillBridge AI: From Claimed Skills to Demonstrated Skills with the AWS Open Source Stack

SkillBridge AI: From Claimed Skills to Demonstrated Skills with the AWS Open Source Stack

SkillBridge AI is an agentic career-readiness system that connects job requirements, a student's existing evidence, personalized engineering tasks, and practical skill verification. Built locally with the AWS open-source stack, it turns a skill gap into something a student can actually build, test, and prove.

full stack ai developer

I Built SkillBridge AI to Turn Job Requirements Into Real Engineering Proof

A resume can say that someone knows Python, AWS, Docker, or databases.
But there is a more useful question:
What can they actually demonstrate?
That question led us to build SkillBridge AI for the First Commit hackathon.

The problem

India's skilling challenge is increasingly being discussed in terms of outcomes rather than credentials alone.
NITI Aayog's 2026 report, Reimagining Skilling for Viksit Bharat@2047, emphasizes stronger connections between education, skilling and employment and highlights employability, progression and livelihoods as important outcomes.
A separate 2026 NITI Aayog working paper, Education and Skilling for Employment: From Credentials to Learning Outcomes, examines India's education and skilling system in the context of employability and the employment ecosystem.
This made us ask:
What happens between "I need this skill" and "I can demonstrate this skill"?
For a software student, the journey often looks like:
Job Description → Learn → Build something → Add it to GitHub → Add the skill to a resume → Apply
The missing part is a continuous system that connects a specific job requirement to the student's existing evidence, identifies the actual gap, creates relevant engineering work, and verifies the result.

What we found in the existing ecosystem

There are already excellent tools for individual parts of this journey.
Job platforms help people discover opportunities.
Learning platforms help people acquire knowledge.
Assessment platforms test specific skills.
GitHub and portfolios allow developers to showcase projects.
Skills-based hiring is also receiving increasing attention from employers. The World Economic Forum's Future of Jobs Report 2025 reports that employers continue to rely on work experience and skills assessments when evaluating candidates. LinkedIn's 2025 Future of Recruiting report similarly highlights the importance recruiters place on accurate skill assessment.
We are not trying to replace these systems.
Instead, we are connecting the pieces.

Our idea: SkillBridge AI

SkillBridge is an agentic system built around one loop:
CLAIM → GAP → BUILD → TEST → VERIFY → PROVE
A student provides:
  • Target job or job description
  • Resume
  • GitHub profile
  • Career goal
The agent then:
  1. Understands the target role.
  1. Extracts the required technical skills.
  1. Analyzes the student's resume.
  1. Examines GitHub repositories and technical evidence.
  1. Builds a skill profile.
  1. Identifies evidence gaps.
  1. Prioritizes the next important gap.
  1. Generates a personalized engineering task.
  1. Evaluates the student's implementation.
  1. Produces traceable evidence for demonstrated skills.
  1. Updates the skill profile.
  1. Decides what the student should work on next.
The important difference is that SkillBridge does not simply tell someone:
"Learn DynamoDB."
Instead, it can say:
"Your target role requires DynamoDB, but your current GitHub work does not demonstrate it. Build this serverless project, implement these requirements, and submit the repository for evaluation."

How the agent works

The core architecture follows an agent loop:
GOAL → DECIDE → TOOL → OBSERVE → STATE → NEXT ACTION
For example:
The student targets a Backend Engineer role.
The agent identifies:
  • Python — demonstrated
  • REST APIs — demonstrated
  • DynamoDB — insufficient evidence
  • Testing — partial evidence
The agent searches its skill and project knowledge, identifies DynamoDB as a relevant gap, and generates a project such as a Serverless Job Tracker.
After the student submits the project, the system analyzes the repository, checks implementation requirements, runs tests, reviews the code, and creates evidence.
The result is not an arbitrary AI score.
It is an evidence record.
For example:
DynamoDB — Demonstrated
Evidence:
  • Repository implementation
  • CRUD operations
  • Test results
  • Commit history
  • Documentation
  • Code review

Building locally with AWS's open-source stack

We chose the Build It track because we wanted to understand the engineering behind the system without making cloud deployment the center of the project.
The official Build It stack includes:
  • Strands Agents SDK
  • OpenSearch
  • SAM CLI + LocalStack
  • Cedar
  • PartyRock
These technologies run locally, which makes it possible to build and demonstrate the system without requiring an AWS cloud deployment.

Strands Agents SDK

Strands provides the agent layer.
The agent can select tools, receive observations, and decide the next step.

OpenSearch

OpenSearch is used as the intelligence and retrieval layer.
We use it for information such as:
  • Skill definitions
  • Job requirements
  • Related technologies
  • Project templates
  • Evidence patterns
This allows the agent to retrieve relevant information instead of relying only on a model's internal knowledge.

SAM CLI + LocalStack

SAM and LocalStack provide our local AWS-style development environment.
This lets us experiment with AWS-compatible infrastructure while keeping the application local.

Cedar

Cedar provides the authorization and policy layer.
For example, a student should be able to access their own evidence but should not be able to modify verification results or access another student's private data.

PartyRock

PartyRock can be used during the experimentation stage for rapid AI prototyping and testing. The core application remains focused on the Build It stack that directly supports the product.

The architecture

Our high-level flow is:
Student ↓ Next.js Application ↓ SkillBridge Agent ↓ Job + Resume + GitHub Tools ↓ OpenSearch ↓ Skill Graph ↓ Gap Engine ↓ Engineering Project ↓ GitHub Submission ↓ Test + Code Evaluation ↓ Evidence Engine ↓ Cedar Policy Check ↓ Verified Skill ↓ Updated Student Profile
The important part is that the system closes the loop.
The student does not simply receive a recommendation.
They receive something to build.
The system then evaluates what they built.

What makes the idea different

We deliberately avoided building another:
  • Resume scorer
  • Course recommender
  • AI career chatbot
  • Generic coding assistant
The central concept is evidence-first career development.
A claimed skill and a demonstrated skill are different things.
SkillBridge tries to make that distinction visible.
Instead of:
"I know AWS."
The student's profile can eventually say:
"Here is the project, repository, implementation, tests and review that demonstrate this capability."

What we learned

Building SkillBridge taught us that an agent is not simply an LLM with a few prompts.
A useful agent needs:
  • Clear state
  • Well-defined tools
  • Reliable observations
  • Deterministic checks
  • Permission boundaries
  • Failure handling
  • Traceable evidence
We also learned that the model should not be treated as the source of truth for everything.
For example, a model can explain why a project demonstrates DynamoDB.
But whether a test actually passed should come from the test runner.
Whether a user is allowed to access evidence should come from the policy layer.
Whether a repository contains a particular implementation should be checked against the actual repository.
That separation between reasoning and verification became one of the most important architectural decisions in the project.

What fought back

The hardest part was not generating project ideas.
It was making the system trustworthy.
We had to think about:
  • What counts as evidence?
  • How do we avoid hallucinated skill claims?
  • How do we evaluate arbitrary student repositories safely?
  • How do we prevent the agent from making unsupported conclusions?
  • How should authorization work?
  • How do we keep the local AWS environment reproducible?
This pushed us toward a hybrid architecture where AI handles interpretation and planning while deterministic components handle validation, testing, permissions and evidence.

What's next

The next version of SkillBridge could expand from individual students to:
  • College project pathways
  • Industry-specific skill graphs
  • Internship preparation
  • Team projects
  • Employer-defined engineering challenges
  • Long-term evidence portfolios
The long-term idea is simple:
A student's technical profile should evolve from what they claim to what they have demonstrated.

Final thought

The goal of SkillBridge is not to predict whether someone is a good engineer.
It is to help them create better evidence of what they can actually build.
Don't just learn the skill.
Build it. Prove it.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article