AI Engineer World's Fair 2024
Git push, get an AI API.
Loading slides…
Read the talk
Git push, get an AI API
A category game leads into GitHub issue triage, showing how ordinary functions, typed model calls and shared embedding logic become a deployed API.
From a talk by Ryan Fox-Tyler
Before you start: Basic familiarity with Git, typed functions and HTTP APIs is helpful; following the workshop's local build steps requires Node.js 20 or newer, Git and a text editor.
How do you judge a roomful of category answers?
How do you turn a familiar category game into something an entire workshop can play? The development approach is incremental: start with a working game, examine its building blocks, then reuse them for GitHub issue triage. Ryan Fox-Tyler introduces a newly launched Hypermode platform with room for things to break. Pushing directly to main is a time-saving workshop shortcut. Public issues provide accessible data for techniques that could also work on customer or product records.
Hyper Categories adapts Scattergories for a larger group. Fox-Tyler describes the traditional format as awkward beyond six or eight players. Each player supplies an answer matching a category and starting letter. A valid answer earns one point, shared among players who give similar answers. For furniture beginning with T, choosing table means sharing credit with everyone else who chooses it. The incentive is to be correct and unusual.
The live round uses T. Participants join by QR code or the workshop link, with a Hypermode jacket offered to the winner. The displayed countdown does not automatically close submissions; the presenters allow extra time. A bot competes too, though its tendency to choose obvious answers works against the game's reward for originality.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Filtering before similarity scoring
Kirk Byers and Francisco tie for first, while the bot finishes fourth. Inspecting individual answers reveals a more useful result than the leaderboard: Tevas has been marked invalid for things you wear. The entrant still wins, but the judgment exposes a weakness in the model-assisted evaluation. The game is available as a deployable template, making its judging pipeline something developers can inspect and change.
The pipeline first validates the starting letter and uses a model to check category membership. During development, an occupation beginning with P exposed another failure: the model accepted P doctor. Adding a dictionary check supplied a constraint that the category model had not reliably enforced. Useful AI behavior comes from combining model judgments with ordinary programmatic checks.
Only after filtering does the game score answers. Similarity clustering treats table and tables as the same answer, so a plural does not evade shared credit. Exact string matching would miss that relationship. The scored results then feed the leaderboard.
Underneath are functions, a collection of user responses, models that support individual functions, and embedding models that support similarity search across the collection. Connections reach other Hypermode components, databases, conventional APIs and model hosts. Those pieces separate the game's rules from its model calls and data access, allowing one part to change without rebuilding the whole application.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Deploying the issue-triage starter
GitHub issues present a related sorting problem: contributors submit reports of uneven quality, and maintainers need to identify issue types, discover similar reports and understand repository-wide trends. The workshop develops those capabilities separately. Its original instructions are reached through the workshop short link or the AI World's Fair tab in Hypermode's documentation. Local prerequisites are a text editor, Node.js 20 or newer, Git and a way to clone a repository; VS Code and GitHub Desktop are presenter preferences.
The historical setup begins with the GitHub issue triage template in Just Ship AI. Selecting Deploy connects a GitHub account. An audience member reports that selecting one existing repository fails and that the permission screen appears to require access to all current and future repositories. The presenters say only the relevant repository should need access and describe the wording as confusing, but the reported failure is not resolved onstage. They offer follow-up inspection and the option to watch without proceeding.
Choose a personal account or organization, a repository name, and public or private visibility. The resulting repository is cloned from the issue-triage template; most workshop work lives in functions/. Clone that repository locally, enter the directory and install its dependencies:
sh
cd functions
npm install
If VS Code still shows red diagnostics, open a TypeScript file and restart its TypeScript language server. The presenter attributes this behavior to an editor issue rather than a failed dependency installation.
There are two template-creation paths:
| Entry point | Additional setup |
|---|---|
| Just Ship AI Deploy | Automates repository creation, Hypermode application installation and organization setup |
| GitHub Use this template | Requires importing the resulting project into Hypermode afterward |
Viewing the repository on GitHub merely opens the template; it does not perform the deployment setup.
Build from functions/:
sh
npm run build
The build reports two exported functions, classifyIssue and trendSummary. The presenter expects Yarn, Bun and pnpm to work as well, but uses npm throughout. Although the source files end in .ts, the language is AssemblyScript, which compiles to WebAssembly. Familiar syntax and package tooling do not make arbitrary JavaScript or TypeScript dependencies compatible. The workshop uses WebAssembly as its execution boundary, with security and performance given as motivations; other language support is future work at this point in the recording.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From retrieved issues to a trend prompt
trendSummary begins with an OpenAI chat-model interface and system and user message objects. Its retrieval helper is conventional application code: it calls the GitHub Issues REST API, substitutes request parameters, supplies headers and can log its progress. Hypermode's secrets mechanism supplies the GitHub token without placing it in source code. The helper returns an array of issue objects.
That array becomes the model's context. The function constructs text containing issue timestamps, user handles and titles, then asks for repository trends rather than a separate summary of every issue. The OpenAI model is referred to as GPT-4.0 in the narration, without an exact API model identifier. The important operation is the transformation from retrieved records into a bounded request for analysis.
The same prompt-building step can be expressed as an AssemblyScript helper:
typescript
class IssueContext {
constructor(
public createdAt: string,
public userHandle: string,
public title: string
) {}
}
function buildTrendContext(issues: IssueContext[]): string {
const lines = new Array<string>();
for (let i = 0; i < issues.length; i++) {
const issue = issues[i];
lines.push(
issue.createdAt + " | " +
issue.userHandle + " | " + issue.title
);
}
return lines.join("\n");
}
The instruction belongs in the system message; the assembled issue context supplies the user message. Keeping construction in a helper makes the fields and formatting easy to change as the summarization behavior is refined.
Hypermode's typed model interface exposes the provider's request structure in the editor. createInput accepts messages, while completion suggestions reveal controls such as temperature, top-p, log probabilities, the number of choices and parallel tool calls. Type errors can fail compilation. An unsupported interface can be implemented by inheriting from a base class, rather than waiting for a built-in adapter.
Fox-Tyler calls this basic retrieval-augmented generation: fetch data, then ask a model to summarize it. Typed interfaces make experimentation easier, but they preserve model-specific controls because models differ in prompts, outputs, hyperparameters and API behavior. A common programming workflow does not make models semantically interchangeable.
The response path is equally ordinary: select the first choice, extract its message content and trim the string. That value could then be logged, stored in a database or passed into another model. The comparison to LangChain arises here, but the demonstrated composition requires only normal function calls and data transformations.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Export a function, get a GraphQL endpoint
The starter is already deployed, but newly written functions follow the title's workflow: commit and push, and Hypermode picks up the change for rollout. For trendSummary, the host configuration contains both an OpenAI API key and a GitHub token. The console's query tab provides GraphiQL for calling the deployed function.
After initially considering Hugging Face Transformers, the presenter chooses the .NET runtime repository without having tested that example beforehand. He reports that the live call fetches the top 100 issues from the .NET runtime repository and returns a trend summary within a few seconds. This is a summary of the retrieved issue set, not evidence that the entire repository has been analyzed.
No GraphQL schema was written for the function. Hypermode generates it from the exported function and its declared inputs. The resulting endpoint can be called through the console, Postman, another GraphQL client, curl or an HTTP client in an application. The exported function signature becomes the API contract.
An audience question makes the type boundary explicit. The workshop version infers GraphQL types, including supported custom scalars, and permits structured output objects. Inputs are restricted to scalars or arrays; structured input objects still require engineering work. Definitions can live in imported files or reusable AssemblyScript libraries distributed through npm. Those limits describe the demonstrated platform rather than a promise about later APIs.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Inspecting what actually ran
After a query, inference history exposes each model invocation's input, output and duration. This matters when a frontend dynamically builds prompts or a function chains several models: the final response alone does not explain what each call received. Token usage also remains available in history even when application code discards that part of the provider response.
Function Runs adds application and system logs grouped by individual execution. When calls overlap, that grouping lets a developer inspect one invocation without mixing its messages with another's. The displayed run history includes an expanded trendSummary execution and its logs.
Deployment history links Git hashes back to source changes, connecting runtime behavior to the code that produced it. The presenters then leave the externally hosted summarizer as an optional exercise: attendees would otherwise need to supply OpenAI and GitHub credentials. The next function uses a model hosted inside Hypermode.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Classifying issues with a small model
classifyIssue does not fetch anything from GitHub. It accepts an issue ID, title and description, logs information about the request, and concatenates the title and description into model input. That formatting is a starting point to adjust for the chosen model. AssemblyScript's familiar syntax helps, although its type requirements can surface where ordinary TypeScript would be more permissive.
The presenter introduces DistilBERT MNLI GitHub Issues, a small, community-contributed Hugging Face model described as already trained for this task. The intended categories include bugs, feature requests and questions, so no training step is needed during the workshop. The imported classification interface comes from the models library's experimental area; the presenter describes it as matching many contemporary Hugging Face classification models.
Classification input is an array of strings, allowing several issues to be handled in one model call. Outputs correspond to those inputs. The demonstration submits one issue and therefore reads prediction zero; a batch would retain the matching predictions for all submitted strings. This differs from the chat model's message-and-choice interface while keeping the familiar sequence of creating input, invoking a model and consuming output.
Running the example exposes a transport problem before a modeling problem. The documentation query contains a complete GitHub issue, including text that needs escaped quotes and newlines. Copying it into the console produces malformed input. The presenter switches to a known-working query and suggests shortening the description for anyone blocked by the copied example. The full issue description remains the intended input; repairing the documentation is left for later. A classification result appears, but its exact label is not stated aloud.
The hosting difference is substantial:
| Function | Model execution | Application input |
|---|---|---|
trendSummary | External OpenAI service | Retrieved issue context |
classifyIssue | Dedicated Hypermode model instance | Supplied title and description |
Deploying the project automatically provisions the small classifier for that project. It can subsequently be customized, while the function continues to use a typed model interface.
The planned confidence-threshold extension is skipped because of time. It would compare a returned confidence score with an application-chosen threshold, without retraining the model. A small AssemblyScript helper captures that policy boundary:
typescript
function acceptedLabel(
label: string,
confidence: f32,
threshold: f32
): string | null {
if (confidence < threshold) {
return null;
}
return label;
}
Here, null lets the caller handle an unaccepted prediction. No threshold is selected or tested in the live exercise, and confidence alone does not establish label accuracy. Participants can continue modifying their running projects afterward.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Declaring a collection and its embedder
The next feature looks for related issues. A proposed bot could respond to a newly opened report with three existing issues that sound similar. The workshop builds the search API underlying that interaction, beginning with storage and indexing.
A collection provides an in-memory key-value store to which Hypermode can apply an index. The presenters distinguish this facility from a general database. In the root hypermode.json manifest, the existing model and host declarations gain a collection declaration. The visible configuration names issuesCollection, a byTitle search method and miniLmEmbedder as its embedding function.
Vector search also needs a model that turns text into comparable vectors. The workshop adds MiniLM from Sentence Transformers, sourced from Hugging Face and hosted on Hypermode. The exact variant is not identified. The presenter commits the collection and model declarations, authenticates the signed commit and pushes before finishing the functions. That early push lets provisioning begin while coding continues; it is a scheduling choice, not a required separate deployment.
Next comes embedder.ts, using an embeddings-model interface. Its output is an array of vectors represented as f32[][]: each inner array contains 32-bit floating-point values. The function returns all predictions. It must also be exported through the module's index file; creating a source file alone does not expose it in the built module. Running npm run build inside functions/ confirms that the embedder appears in the output. Raw vectors are now available, but they do not yet constitute a usable search feature.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Returning useful search results
The search function goes into a new file and is exported from the index as well. It imports the collections interface and defines a SimilarIssue class for structured results. Returning an array of those objects exercises the structured-output support discussed earlier: the build generates the corresponding GraphQL output type.
The function searches the manifest-configured collection and requests the top three results, including their text. Returning text suits this demonstration because the caller wants to inspect the matches immediately. An application that will fetch authoritative records from a database could instead request IDs and avoid transferring large text fields unnecessarily.
The presenter commits and pushes the search functions, then remembers to check the local build. Compilation reports the custom SimilarIssue type. At recording time, local compilation is available but local function execution is not; execution happens after deployment. In the console, both pushes have appeared, and the project now shows its issues collection, four functions and the added embedding model.
To populate the collection, the presenter downloads issues.csv, linked from the workshop documentation and described as containing previously scraped Transformers issues, then uploads it through the console. This is a convenient seed operation. The same ingestion could be driven by a function accepting API input or fetching issues from GitHub.
The collection configuration connects ingestion to indexing:
- Add a record through code or file upload.
- Hypermode invokes the configured embedding function for the new content.
- The resulting vector becomes available for similarity search.
- A search uses that same embedding function for its query text.
Stored content and queries must be embedded consistently. Here, both paths use the configured function, keeping the model choice aligned. Embedding runs in the background, so the upload and its inference-history entries do not necessarily become visible at the same instant.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Nearest neighbors are not confirmed duplicates
The first attempt to inspect embedding history does not show the expected records. The presenters try a search while suspecting that ingestion is still queued; initially, it appears to return nothing. The test input is a proposed issue asking to add a Spanish version of the README. In the imagined application, a bot would use this request to check whether someone had already asked for it.
Once the upload has finished, results mention a Turkish README, a French version and other language-related work. The presenter does not see a Spanish README duplicate. These are the most similar available records, which is a narrower conclusion than declaring the new issue redundant. A top-k search returns neighbors even when none is an exact match; the application still needs a policy for interpreting them. No bot comment is posted during this demonstration.
The missing inference records then appear. The presenter estimates that ingestion was split into batches of about 25 items and observes roughly two seconds for one batch and one second for another. Those are observations from the live run, with no hardware or repeatability comparison supplied. Expanding the history reveals the floating-point arrays: the embeddings that the search operation uses. The delayed visibility resolves during the demo, after the search itself has already produced useful results.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Applying the functions to other data
The workshop closes with room to continue in the documentation or with help after the session. HTTP calls and collection operations are available in the demonstrated platform; connections to arbitrary Postgres databases are explicitly described as forthcoming, not available yet. That boundary matters when deciding where authoritative data will live and how a function will retrieve it.
The closing slide broadens the same operations beyond GitHub: find similar issues, cases, patients, entities or products; classify type, urgency, propensity, quality or value; filter spam, duplicates, off-topic material, toxicity or outliers. Each application needs its own rules and evaluation, but the integration pattern is recognizable: put retrieval and validation in functions, call a suitable model, and expose a result another application can use.
Just Ship AI templates are offered as starting points rather than requiring participants to begin from an empty repository. At the workshop, attendees receive a fourteen-day Hypermode trial and are invited to reply to their email to claim credits mentioned earlier that day. The presenters also offer help adapting the setup to a team's own context. The practical next iteration is to replace the public issue data with the records and decisions that matter to that application.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Explains compilation to WebAssembly, differences from TypeScript, and package compatibility.
Reference for retrieving repository issues, including pagination, filtering, authentication and pull-request handling.
Further reading
Documents a distilled classifier for issues, feature requests and questions, including its training approach and inference examples.
A sentence-embedding model with examples for generating vectors and measuring semantic similarity.
Updates since the talk
- Modus source archiveRepository
Hypermode's WebAssembly framework with generated APIs, Go and AssemblyScript support, and local development instructions. Archived September 11, 2025.
Full transcript
Loading transcript…