ADTEA_TayGood

Inspiration

Anyone who's been staffed onto a project knows the lineup matters more than the headcount. Most org charts assemble teams by who's free on the calendar, not who actually fits — so you end up with five capable people who've never worked together and a sixth nobody needed. We wanted to flip that: let the work define the team. If we could quantify what a project genuinely requires (skills and scale) and what makes people work well together (shared history and friction), we could build teams sized and matched on evidence instead of gut feel.

What it does

ADTEA takes a plain-text project goal and a workload slider (1–10) and returns a recommended team. It dynamically decides the team size from the workload, translates the goal description into a 4-dimensional target skill vector (Tech, Management, Design, Operations), then scores every employee two ways: how well their skill vector matches the project using cosine similarity, and how well they've historically collaborated with the rest of the candidate pool using a synergy score drawn from past shared tasks. The result renders as an interactive node-link graph — every employee is a node, past collaborations are the links — and when you run the engine, the chosen team's sub-graph lights up. Below the graph, the picks are sorted into department columns, each with a suggested task assignment.

How we built it

It's a single Next.js (App Router) app with Tailwind for the UI, no backend and no database — everything runs in-memory off a static dataset.json so we could move fast and demo anywhere. Each employee carries a normalized 4-element skill vector plus knowledge tags, and collaboration history lives in a flat synergy matrix keyed by employee-pair IDs, storing past collaboration counts and a sentiment score from -1 to 1. The matching pipeline is pure JavaScript: parse the goal into a target vector, compute cosine similarity per candidate, then evaluate team combinations by averaging the pairwise sentiment scores, and select the set that maximizes both individual capability and team chemistry. Team size comes from a deterministic rule (Math.ceil(workload / 2) + 1) rather than a fixed squad size. We rendered the web graph with a D3 force layout and wired the highlight state so the selected cluster glows on allocation.

Challenges we ran into

The combinatorics hit first: scoring every possible team against the synergy matrix blows up fast, so we had to prune the candidate pool by skill fit before evaluating chemistry rather than brute-forcing every combination. Turning free-text into a meaningful 4D vector with no training data and no time was the second wall — we leaned on keyword mapping to mock the goal-to-vector translation convincingly for the demo. And making the D3 graph feel alive (nodes not overlapping, links readable, the selected sub-graph clearly glowing) ate more of the eight hours than we'd like to admit.

Accomplishments that we're proud of

A working end-to-end loop in eight hours: type a goal, drag a slider, watch a real graph light up with a defensible team. We're proud that the matching isn't a black box — cosine similarity for skill fit and an averaged sentiment score for chemistry are both things we can point at and explain to a judge. And keeping the whole system in-memory and dependency-light meant it ran instantly with zero setup, which made the live demo bulletproof.

What we learned

Representing people as vectors plus a graph turns a fuzzy HR problem into something you can actually compute. Cosine similarity gives a lot of mileage for very little code. The synergy matrix is where the real signal lives — skill fit alone just picks competent strangers. In a time box, faking the hard part (goal → vector) cleanly beats half-building the real thing. D3 force-directed graphs are deceptively fiddly.

What's next for ADTEA_TayGood

Replace the keyword mock with a real embedding model so the goal-to-vector step is genuine NLP. Swap static JSON for live data — pull skills from HR systems and synergy from actual collaboration signals like shared docs, commits, and chat. Promote the age/experience balancing toggles from UI stubs to real constraints in the optimizer, and let managers lock or veto picks and re-run. Longer term, we want to learn the sentiment scores from project outcomes instead of hand-labeling them, so the engine gets better over time at predicting which teams actually ship.

Built With

• claude
• css
• html
• javascript