Gradland
← GitHub Hot
🔥

GitHub Hot — 29 May 2026

29 May 2026·21 min readGitHubOpen SourceTools

Top 10 repos trending on GitHub this week — what they do, why they matter, and how to use them in your projects.

1. op7418/guizang-social-card-skill

1,151 stars this week · HTML · agent-skill ai-agent anthropic claude-code

A Claude Code skill that converts any text, article, or screenshot into polished social media image carousels (Xiaohongshu 3:4 + WeChat 21:9/1:1) using pre-built Editorial and Swiss design systems, rendered to PNG via Playwright.

Use case

The real problem: writing a great blog post or career guide takes hours, but distributing it on visual-first platforms (Instagram, LinkedIn carousels, WeChat) requires a second round of design work most developers skip entirely. This skill lets an AI agent take a finished markdown post, pick a layout from 28 templates, and export a ready-to-post image series — no Figma, no Canva, no manual resizing. Concrete example: you publish a '5 visa mistakes 485 graduates make' post on Gradland, then immediately ask Claude to generate a 6-card Swiss-style carousel from it for LinkedIn and a WeChat cover pair for sharing in WeChat groups.

Why it's trending

Claude Code skills as installable, composable units are a genuinely new distribution primitive — this repo is one of the first to demonstrate that a visual design workflow (not just code generation) can be packaged as a skill and invoked conversationally. It's trending because the combination of agentic HTML templating + Playwright headless rendering sidesteps every image-generation API cost and latency issue.

How to use it

  1. Install the skill: npx skills add https://github.com/op7418/guizang-social-card-skill --skill guizang-social-card-skill (or clone to ~/.claude/skills/ manually).
  2. Confirm installation by checking that SKILL.md, assets/, and references/ exist in the cloned directory.
  3. Ensure Playwright is available: npx playwright install chromium — the skill shells out to it for HTML→PNG rendering.
  4. Invoke conversationally inside Claude Code: paste your article or markdown and say Generate a 5-card Swiss-style Xiaohongshu carousel in IKB blue from this post.
  5. The skill writes single-file HTML to a temp directory, launches a headless Chromium instance, screenshots each card at the correct canvas size (1080×1440 for 3:4), and saves PNGs to your working directory — no API calls, no external services.

How I could use this

  1. Auto-generate a LinkedIn carousel for every Gradland blog post at publish time: wire a Next.js API route that, after a new markdown file lands in content/posts/, calls Claude Code with the post content and this skill to produce a 5-card Swiss-style image set, then store the PNGs in Supabase Storage and surface a 'Download for LinkedIn' button on each post page — zero extra design work per post.
  2. Career tips as visual cards for the jobs/visa section: take the structured data you already have (485 visa timeline, salary bands by role, ACS skill assessment checklist) and render them as Swiss-grid infographic cards users can screenshot and share — a 'Share this tip' button on visa-tracker milestones that generates a card on demand via a /api/share-card route using this skill's HTML templates.
  3. Automate the githot digest as a visual thread: the daily githot GitHub Actions workflow already writes markdown summaries of trending repos — pipe each entry through this skill to produce a consistent Editorial-style card (repo name, star count, one-line hook, design language accent colour), bundle them into a carousel, and post or cache them so the /githot page shows a visual feed alongside the text digest.

2. study8677/awesome-architecture

803 stars this week · Vue · ai-agents architecture-decision-records architecture-patterns awesome

21 battle-tested, interactive architecture diagrams (RAG, AI gateway, agents, vector DB, microservices) with every layer linked to real open-source implementations — bilingual Chinese/English.

Use case

System design interviews and AI feature architecture suffer from the same problem: you know the concepts but can't translate them into a concrete component list. This repo solves that with opinionated, clickable blueprints — e.g., the RAG map shows exactly which vector DB, embedding model, retrieval layer, and LLM slot to fill, then links you to a working open-source prototype for each. Useful when you need to pitch an architecture to a team, prep for a FAANG system design round, or just avoid reinventing a well-understood pattern.

Why it's trending

The AI architecture maps (RAG, agent orchestration, inference serving) landed exactly when every team is scrambling to design their first production AI system and the existing 'awesome-system-design' lists don't cover post-GPT patterns. The bilingual format also hits a large underserved audience — Chinese-speaking engineers in Australia and globally who interview at English-speaking companies.

How to use it

  1. Open the interactive site at https://study8677.github.io/awesome-architecture/ — no install needed, diagrams are navigable in-browser.,2. Pick a relevant map (start with 'AI Gateway' or 'RAG Pipeline' if you're building LLM features; 'Microservices' or 'Distributed Systems' for backend interview prep).,3. Each node in the diagram links to a real OSS prototype — click through to see actual implementation code, not just theory.,4. For guided design, install the companion Claude Code skill: git clone https://github.com/study8677/architecture-copilot and follow the setup to get an interactive architecture co-pilot inside your editor.,5. For interview prep, use the language-agnostic tutorial section to practice articulating trade-offs (consistency vs. availability, sync vs. async, monolith vs. micro) using the repo's templates as anchor points.

How I could use this

  1. Add a 'System Design Explainer' post series on the Gradland blog — one post per architecture pattern from this repo (RAG, AI gateway, event-driven), each rendered as a Mermaid diagram generated by Claude Haiku at build time. Target keyword: 'system design interview Australia' — directly relevant to your 485/482 visa audience preparing for tech interviews at Atlassian, Canva, Telstra.
  2. Build a 'System Design Mock Interview' tool in the career tools section: user picks a topic (URL shortener, rate limiter, AI pipeline), Claude Sonnet conducts a timed 45-min mock using the repo's architecture templates as the answer rubric, then scores the response against the same trade-off dimensions the repo documents (scalability, fault tolerance, data consistency). This fills a real gap — no existing tool evaluates system design answers against a structured checklist.
  3. Use the AI gateway architecture map as the blueprint to refactor Gradland's own Claude routing layer — implement a proper gateway pattern with a single entry point that handles model selection (Haiku vs Sonnet vs Opus), per-endpoint rate limiting, usage telemetry, and fallback logic. Right now that logic is scattered across individual route handlers; centralising it following this proven pattern reduces billing risk and makes adding new AI endpoints a 5-line change.

3. helloianneo/ian-xiaohei-illustrations

748 stars this week · various · ai-agent chinese codex-skill handdrawn

A Codex Skill that turns abstract concepts in Chinese articles into hand-drawn 16:9 inline illustrations using a consistent visual language — not generic image prompts, but a structured cognitive-to-visual pipeline.

Use case

When you write a Chinese article about a mental model, workflow, or system and need inline illustrations that explain a specific idea (not just decorate the page), you run this skill against your article text. It identifies 4–8 cognitive anchor points, generates a shot list with composition and annotation suggestions, and produces white-background hand-drawn PNGs. Example: a post about 'breaking down complex decisions' gets a sketch of the Xiaohei character operating a sorting machine labelled with your framework's stages — not a stock photo, not a Canva template.

Why it's trending

Codex Skills as a composable, repo-cloneable agent primitive are gaining traction fast — this repo is riding that wave while also solving the specific pain point that most AI image generation tools produce generic visuals that don't encode the article's actual argument. The Chinese-language content creator market (Xiaohongshu, WeChat, Notion) is underserved by English-centric image tools, so this fills a real gap.

How to use it

  1. Clone and install the skill: git clone https://github.com/helloianneo/ian-xiaohei-illustrations.git && cp -R ./ian-xiaohei-illustrations "${CODEX_HOME:-$HOME/.codex}/skills/",2. Open a Codex session and reference the skill: @ian-xiaohei-illustrations — paste your article text (Chinese or bilingual) as context.,3. The skill extracts cognitive anchors — judgements, processes, metaphors, states — and produces a shot list: one illustration per anchor, each with a theme, Xiaohei action, and Chinese annotation suggestions.,4. Review the shot list and approve or prune it, then let the agent generate PNGs into assets/<article-slug>-illustrations/.,5. Drop the PNGs directly into your markdown or Notion doc as inline images — they're sized 16:9 for standard content column widths.

How I could use this

  1. Use this to generate a signature illustration style for Gradland blog posts — every 'career-edge' article gets a custom Xiaohei sketch encoding the core mental model (e.g. the '482 visa decision tree' as a Xiaohei operating a railway switch). Consistent visual identity across posts builds brand recognition faster than any header template.
  2. Generate explainer illustrations for the visa tracker feature — instead of a text-heavy FAQ, each visa stage (lodgement → bridging visa → grant) gets a hand-drawn state diagram with Xiaohei as the applicant. Embed these as static assets in the content/visa-news/ markdown files to increase time-on-page for international students researching their pathway.
  3. Fork the Codex Skill pattern itself: build a gradland-career-illustrations skill that encodes Gradland's specific visual vocabulary (Eastern Ink palette, comic-panel borders) and generates inline diagrams for the learning path pages — so when the AI generates a new roadmap for 'Backend Engineer in Australia', it auto-produces a matching illustration showing the skill progression as a Xiaohei climbing a scaffold, ready to drop into the LearnPageClient.tsx render.

4. UditAkhourii/adhd

511 stars this week · TypeScript · adhd agents ai ai-agents

ADHD forces LLMs to generate genuinely divergent ideas by spawning N isolated reasoning processes under distorted cognitive frames — then scores and prunes the results — instead of letting chain-of-thought anchor on its first guess.

Use case

Standard CoT and even Tree-of-Thought still share context across branches, so the model anchors early and produces variations on the same idea. ADHD fixes this architecturally: each branch gets zero shared context and a deliberately skewed cognitive frame (e.g. 'paranoid security auditor', 'UX nihilist', 'systems programmer who hates abstractions'). Concrete example: ask 'what should my resume scoring API return?' and instead of three variations on the same object shape, you get one from a performance-first frame, one from a DX-first frame, one from a mobile-client frame — then a critic pass kills the duplicates and surfaces what actually diverges.

Why it's trending

The Claude Agent SDK dropped recently and ADHD is one of the first third-party skills built on it — so it's catching attention as a reference implementation of the skill primitive. It also lands at the exact moment developers are hitting the ceiling of single-pass LLM reasoning for non-trivial design decisions.

How to use it

  1. Install: npm install adhd-agent (requires Node ≥18, Claude Code Pro or ANTHROPIC_API_KEY set).
  2. In your Claude Code session or agent script, register the skill: the package exposes it as a Claude Code skill you invoke with /adhd <your-question>.
  3. Frame your prompt as an open design question — 'Give me 5 architecturally distinct ways to structure visa-status caching in a Next.js app' works better than 'how do I cache things'.
  4. ADHD fans out parallel agents under different cognitive frames, each in isolated context, then runs a critic that scores, clusters near-duplicates, prunes convergent traps, and returns only the survivors with reasoning.
  5. Pipe the structured output (JSON array of scored ideas) into your own decision logic or just read the ranked list — each entry includes the frame it was generated under so you know which lens to credit.

How I could use this

  1. Wire ADHD into the Gradland 'Career Edge' content pipeline: before writing a post, run the article topic through ADHD with frames like 'skeptical senior engineer', 'anxious 485 visa holder', and 'HR manager reviewing 200 apps' — the divergent angles become the H2 sections, guaranteeing posts that cover the topic from multiple stakeholder perspectives instead of one obvious take.
  2. Use ADHD inside the resume analyser endpoint: instead of one Claude pass scoring a resume, fan out three isolated critic agents under frames ('ATS keyword scanner', 'hiring manager skimming for 10 seconds', 'technical lead stress-testing claims') — prune duplicated feedback, then surface the top 3 highest-signal improvements ranked by which frame flagged them most consistently.
  3. Build a 'divergent interview prep' mode in the interview tool: given a job description, run ADHD with frames like 'behavioral interviewer', 'system design sadist', 'culture-fit screener', and 'immigration-aware HR' — the survivors become a question bank that's structurally diverse rather than N paraphrases of 'tell me about a time you led a team'.

5. withkynam/vibecode-pro-max-kit

492 stars this week · JavaScript · agentic ai-agents ai-coding-assistant ai-development

A structured harness that forces AI coding agents to plan before coding and persists context across sessions, solving the 'AI amnesia' problem that kills multi-session feature development.

Use case

When you're building a complex feature across multiple Claude Code or Cursor sessions, each new session starts blind — the AI re-invents decisions, breaks conventions, and produces inconsistent code. This kit inserts a mandatory spec layer (PRD + backlog) between 'I want X' and 'write the code', then maintains a self-updating knowledge base so session 5 inherits every decision made in sessions 1–4. Concrete example: building a resume analyser across a week of sessions without every Claude invocation re-guessing your scoring schema.

Why it's trending

Claude Code's CLAUDE.md and Cursor's .cursorrules shipped memory primitives but no workflow on top of them — this kit is the opinionated layer that fills that gap, landing at exactly the moment developers are hitting context rot at scale. 492 stars in one week tracks with the broader 'vibe coding went wrong' backlash and the search for structured AI-native dev workflows.

How to use it

  1. Copy the kit's CLAUDE.md, AGENTS.md, and skills directory into your project root — these are the harness config files, not your app code.,2. Run the spec agent first: claude '/spec create resume-analyser' — it generates a PRD with requirements, constraints, and file-change list before any code is written.,3. The backlog agent breaks the PRD into ordered tasks; you approve or edit the task list, then hand it to the coder agent: claude '/build'.,4. After each session, the memory agent runs automatically and updates a knowledge base file (like a self-maintaining CLAUDE.md) with decisions made, patterns used, and gotchas hit.,5. Next session, the harness bootstraps context from the knowledge base — the AI picks up exactly where it left off without you re-explaining the schema, auth pattern, or design tokens.

How I could use this

  1. Wire the spec-driven PRD pattern into Gradland's TODO.md workflow — instead of free-form feature entries, generate structured PRDs with a Claude skill that forces you to define affected files, acceptance criteria, and rollback plan before any code touches auth or billing (directly maps to your §17 human-review gate).
  2. Adapt the memory agent's self-update pattern for the resume analyser: after each user session, a background job runs Claude Haiku to extract what the user changed, why their score improved, and what job titles they're targeting — building a per-user career context file that makes every subsequent analysis smarter without retraining.
  3. Use the multi-agent routing architecture (12 agents, each scoped to a skill) as the blueprint for a 'career pathway' orchestrator on Gradland: a planner agent reads the user's visa status + current skills, routes sub-tasks to a gap-analyser agent, a job-market agent (Jora/Adzuna data), and a learning-path agent, then a synthesiser agent merges outputs into a single ranked action plan — all in one /api/career/plan call using Claude Sonnet for the synthesiser and Haiku for the sub-agents.

6. harrietteehisqu7759383/kms-pico-latest-april-2026

449 stars this week · C# · kms-activator-windows-10-pro kms-client kms-office kms-pico-office-2019-activator

A secure, educational toolkit for understanding KMS activation, designed for lab environments.

Use case

A secure, educational toolkit for understanding KMS activation, designed for lab environments.

Why it's trending

How to use it

How I could use this

7. Michaelliv/pi-dynamic-workflows

407 stars this week · TypeScript

pi-dynamic-workflows ports Claude Code's fan-out workflow engine to Pi, letting a model write a JavaScript orchestration script that spawns isolated subagents in parallel instead of answering sequentially.

Use case

When a single LLM context window is too narrow for a large task — say, auditing 40 API routes across a Next.js app for missing rate limiting — this lets the model author a script that fans out one subagent per route simultaneously, then synthesizes all results into a single report. Without it, you either truncate context or do 40 sequential calls; with it, you get parallel isolation and live progress.

Why it's trending

Anthropic published the Claude Code dynamic workflows blog post in May 2025, and this repo is the first third-party port of that exact pattern to Pi — so it caught the wave of developer interest right as the Claude Code implementation went public. It validates that the orchestration model (script → fan-out → synthesize) is framework-agnostic.

How to use it

  1. Install Pi if you haven't: npm install -g @earendil-works/pi. 2. Install the extension: pi install npm:pi-dynamic-workflows, then run /reload in your Pi session. 3. Ask in plain language: 'Run a workflow to audit every API route in src/app/api for missing auth checks.' Pi writes the orchestration script and calls the workflow tool automatically. 4. To write your own script, export a meta literal first, then use phase(), agent(), parallel(), and pipeline() globals — e.g.:
export const meta = { name: 'audit_routes', description: 'Check auth on all routes', phases: [{ title: 'Scan' }, { title: 'Audit' }] }
phase('Scan')
const routes = await agent('List every file under app/api/', { label: 'route list' })
phase('Audit')
const results = await parallel(routes.map(r => () => agent(`Does ${r} call requireSubscription or getUser?`, { label: r })))
return results
``` 5. Press Esc to cancel mid-run; active subagents abort cleanly.

**How I could use this**

1. Run a nightly Pi workflow that fans out one subagent per content directory (`content/posts/`, `content/digest/`, `content/githot/`, `content/ai-news/`, `content/visa-news/`) to check frontmatter schema compliance, missing slugs, and broken internal links — then POST a Supabase insert with the audit report so you can surface content health on your admin dashboard.
2. Wire a Pi workflow into the resume analyser flow: one subagent extracts skills from the uploaded resume, a parallel set of subagents each queries a different job source (Jora, ACS, Adzuna, JSearch) for matching AU IT roles, and a synthesis agent scores fit per role against the 482/485/PR visa requirements — all in one orchestrated call rather than four sequential fetches.
3. Build a Claude-backed 'codebase security sweep' workflow triggered via a GitHub Actions `workflow_dispatch` input: it uses `pipeline()` to fan out one subagent per API route file in `app/api/`, each checking for the mandatory `requireSubscription()` + `checkEndpointRateLimit()` pattern from AGENTS.md §5.1, and returns a Markdown report committed back to the repo as `reports/security-YYYY-MM-DD.md`.

---

## 8. [alfiyahkamilah1239298/WallpaperDownloader-26](https://github.com/alfiyahkamilah1239298/WallpaperDownloader-26)

**400 stars this week** · TypeScript · `live-wallpapers` `steamworkshop` `wallpaper-changer` `wallpaper-engine-key-gen`

A comprehensive community toolkit for organizing, creating, and managing dynamic wallpaper projects and assets, enhancing your Wallpaper Engine experience.

**Use case**

A comprehensive community toolkit for organizing, creating, and managing dynamic wallpaper projects and assets, enhancing your Wallpaper Engine experience.

**Why it's trending**



**How to use it**



**How I could use this**



---

## 9. [FlashML-org/flashlib](https://github.com/FlashML-org/flashlib)

**388 stars this week** · Python

GPU-accelerated drop-in replacements for sklearn's classical ML operators (kmeans, PCA, UMAP, etc.) that run 10–100x faster on CUDA hardware via Triton and CuteDSL.

**Use case**

When you're running clustering or dimensionality reduction on large datasets — say, embedding 500k resume chunks with OpenAI and then running UMAP + HDBSCAN to cluster them by role/skill — sklearn's CPU implementations become the bottleneck. FlashLib lets you run the same pipeline on GPU without rewriting anything: same sklearn-style API, same output shape, just dramatically faster. Concrete example: `flash_hdbscan` on 1M 128-dim embeddings instead of waiting 4 minutes with sklearn.

**Why it's trending**

Classical ML on GPU has been a known gap — PyTorch handles neural nets, RAPIDS/cuML exists but requires a heavy CUDA stack, and sklearn remains CPU-only. FlashLib fills that gap with a lightweight Triton-based layer that works wherever PyTorch does, and the `flashlib.info` submodule (which predicts FLOPs and runtime in ~5µs with no GPU required) is a genuinely novel idea that's getting traction in the LLM agent tooling space.

**How to use it**

1. Install: `pip install flashlib` (requires a CUDA GPU; works in Colab T4/A100 or any cloud GPU instance).,2. Generate or load your embeddings as a `torch.Tensor` on CUDA — e.g. embed job descriptions with `text-embedding-3-small` and move to GPU with `.to('cuda')`.,3. Run a primitive: `labels, centroids, n_iter = flash_kmeans(embeddings, n_clusters=128, max_iters=30)` — returns standard torch tensors you can inspect or move back to CPU.,4. Use `flashlib.info` to budget your pipeline without a GPU: `info.estimate('umap', shape=(50_000, 1536), params={'n_components': 2}, device='A10G').summary_line()` — useful for sizing cloud instances before you pay for them.,5. For sklearn interop, use the class API: `from flashlib import HDBSCAN; model = HDBSCAN(min_cluster_size=10).fit(X_gpu)` — `.labels_` returns a CPU numpy array matching sklearn's contract.

**How I could use this**

1. Build a 'skill cluster map' visualisation for the blog: embed all job postings you've scraped with `text-embedding-3-small`, run `flash_umap` + `flash_hdbscan` to cluster them, then render an interactive 2D scatter plot (React + D3 or Recharts) showing which skills cluster together in the AU IT market. Publish the methodology as a post — it's a concrete, data-driven piece that demonstrates ML chops to hiring managers.
2. Add a resume similarity feature to the career tools: embed uploaded resumes and the scraped job descriptions using the same model, then use `flash_knn` to find the top-10 closest job postings to a candidate's resume vector. This is faster and more semantically precise than keyword matching, and you can expose it via a `/api/resume/matches` route that calls FlashLib on a GPU-backed serverless function (Modal or RunPod) — avoids needing a persistent GPU server.
3. Use `flashlib.info` inside a Claude tool call to let the AI agent reason about compute cost before spinning up GPU work — e.g. when a user requests a 'deep skill analysis' on 100k job postings, the agent calls `info.estimate('pca', shape=(100_000, 1536))` first, reports the estimated runtime to the user, and asks for confirmation before launching the expensive job. This makes the AI feel considered rather than opaque about cost.

---

## 10. [Sophomoresty/gemini-web2api](https://github.com/Sophomoresty/gemini-web2api)

**386 stars this week** · Python

A local proxy server that wraps Google Gemini's web UI as an OpenAI-compatible API, giving you free Gemini access through any OpenAI SDK client.

**Use case**

If you're paying for OpenAI API credits but have a free Gemini web account, this lets you swap in Gemini as a zero-cost drop-in replacement — no new SDK, no API key setup. Concretely: you can point your existing `new OpenAI({ baseUrl })` calls at `localhost:8081` and suddenly you're running Gemini Flash Thinking with 20k+ char output at zero marginal cost.

**Why it's trending**

Gemini 2.5 Pro and Flash just landed significantly better benchmarks than GPT-4o in several coding and reasoning tasks, so developers are actively hunting for free/cheap ways to experiment with Gemini without committing to Google AI Studio API limits. A zero-dependency single-file proxy that also supports tool calling hit a sweet spot this week.

**How to use it**

1. Clone and run: `git clone https://github.com/Sophomoresty/gemini-web2api && python gemini_web2api.py` — server starts on `http://localhost:8081/v1`.
2. Log into Gemini in your browser so the session cookies are present (the proxy scrapes the web UI, so you need an active session).
3. Point your OpenAI client at the local server:
```python
from openai import OpenAI
client = OpenAI(base_url='http://localhost:8081/v1', api_key='any-string')
resp = client.chat.completions.create(
    model='gemini-3.5-flash-thinking',
    messages=[{'role': 'user', 'content': 'Review this resume bullet...'}]
)
  1. To use web search, include @search in your model name or prompt — Gemini's native search fires automatically.
  2. Adjust thinking depth with @think=0 (deepest) to @think=4 (fastest) appended to the model string.

How I could use this

  1. Wire it into your blog's githot digest pipeline as a free summarisation layer — instead of burning Anthropic Haiku tokens on scripts/fetch-ai-news.ts, route the 'summarise this README' prompts through the local Gemini proxy during development and local testing where billing doesn't matter.
  2. Build a free-tier career tool fallback: when a logged-out visitor tries the resume analyser, instead of gating them entirely behind a subscription, proxy their first analysis through Gemini Flash via this server — gives them a real result without spending Claude API credits on unauthenticated users.
  3. Use Gemini Flash Thinking's 20k+ char output limit (much higher than Claude Haiku's default) as a backend for generating long-form learning path content — full 8-week roadmaps, detailed interview question banks — without hitting token truncation, then cache the result in Supabase so you only generate once per topic.
← All issuesGo build something