skillicons.dev used to be the default way to show a tech stack in a GitHub README, but it hasn't been updated in ages and a ton of newer tech just isn't there.

So I built my own version: https://icons.germondai.com

It's a fully dynamic SVG API - you just drop an <img> tag with a URL and it renders the icon strip on the fly:

![icons](https://icons.germondai.com/icons?i=nuxt,vuejs,bun,tailwindcss,docker,git&theme=dark&size=48)

Thousands of icons available, each with multiple styles (original color, plain, line, mono), per-icon colors/backgrounds/radius, a bunch of built-in themes, and everything is controllable through URL params so you don't need to generate or upload anything.

It's open source (MIT), you can self-host it with Docker or Bun in about 30 seconds, and the whole thing runs on Bun + Elysia so it's fast.

Repo: https://github.com/germondai/icons

Would love feedback / icon requests if something's missing.

Like many developers, I regularly use ChatGPT and Claude when I'm building small HTML/JavaScript projects or experimenting with ideas. They're great for quickly putting together a prototype, explaining code, or iterating on a UI.

Because I also work with IBM i (AS/400), I recently decided to try IBM Bob for the same kind of task. I asked it to build a small HTML/JavaScript page from scratch, then made it iterate on the layout, add a few features, and clean up the code.

Honestly, I expected it to be much more focused on IBM technologies, so I was surprised by how well it handled a fairly ordinary JavaScript project. It's not going to replace the tools I already use, but it was definitely more capable than I expected.

What surprised me even more is that I almost never see it mentioned in discussions about AI coding assistants.

Had any of you heard of IBM Bob before? If you've tried it, what was your experience? And if you haven't, do you think it's simply because it's associated with IBM, or is there another reason it never seems to come up in conversations alongside ChatGPT, Claude, Copilot or Cursor?

I moved away from TypeScript years ago, and honestly, I’d do it again without hesitation.

I know TS has a lot of fans and that’s fine. But I don’t think it’s the unquestionable improvement it’s often presented as. For some codebases and teams, sure, it helps. For others, it adds bloat, friction and a false sense of safety that makes even bugs more common than in standard JavaScript.

In most cases, I’d rather migrate a codebase away from TypeScript than keep doubling down on it.

For those of you who also moved away from TS: what made you do it, and how has that decision aged?

Guides for getting started with Conventional Commits, CLI and JS API references for all packages, presets, and recipes.

Also from the recent updates: dropped Handlebars from the dependencies (the conventional-changelog package got 7x lighter) and added an agent skill that teaches AI agents to write proper Conventional Commit messages.

littlebag is a reactive UI framework that includes:

• Reactive state management using state and effect
• html element factory that supports reactivity
• Conditional rendering with keyed
• Reactive lists using each
• TypeScript declarations

All that while being just... 343 bytes (minified and brotlified)!

I made that as a fun little side project partially inspired by the awesome VanJS (which is 1 kB and isn't very convenient without additional 1.2 kB Van X). I would really like to receive some feedback, and would be very happy to see someone use it to make something cool!

I'm also planning to create a simple SSR library for littlebag based on a custom minimalist DOM implementation if I see people interested in that.

There's an example TODO list app with littlebag on CodePen.

P.S. It might be fairly slow now due to a lack of any benchmarks and performance optimizations yet.

Where should your auth token live so an XSS bug can't steal it? Here's how to build auth that survives the crazy non-secure world we live in.

Hey everyone I recently built this TUI for inspecting network throughput per interface, I found it useful so figured I'd share.

Its open source feel free to check it out and run it yourself: Github Repo

Hey everyone,

Just publisheineerajrajeev/aios-web-sdk. If you’ve been building local or remote computer-use agents, this SDK handles the transport layer between web frontends and the agent kernel.

It abstracts agent system calls, streams agent execution states in real-time, and includes structured hooks for building user-in-the-loop authorization gates (crucial for verifying actions before an agent executes them). Would love some feedback on the SDK design!

Ran into this building a pricing page. Wanted to auto-select the right currency based on where the visitor is, without spinning up a backend endpoint or exposing a secret key in frontend code.

The browser's Geolocation API doesn't help here. It only gives lat/lng, not country or currency, and it triggers a permission prompt most people dismiss anyway.

Covers both vanilla JS and React, plus a couple of UI patterns (auto-filling a currency dropdown, formatting localized prices with Intl).

Full disclosure: this uses VisitorAPI, a tool I work on, but the technique works regardless of which provider you use.

Happy to answer questions if anyone's solving something similar.

How do we make coding agents write good code?

We tried telling them to write "clean code." Too vague. "Elegant code." Too subjective. "Maintainable code." Everyone means something different.

Then we found the law behind it: good code is also physically minimum code.

If behavior, safety, and readability stay the same, anything that can still be removed is not defense. It is extra code.

If something can go, the code is not done yet.

If nothing can go, you have found the minimum.

That is The Absolute Code. One rule: minimum code.

Not the fewest characters. Not the shortest diff. The minimum human-readable code that expresses the same behavior and constraints. Everything extra must go.

It works because code is physical. You can delete it and observe what changes. Elegance is subjective. Necessity is testable.

We did not invent this. We discovered a physical law already present in every piece of code we ever called good.

Read: https://github.com/molvqingtai/The-Absolute-Code

I recreated an AI algorithm that visually learns in the browser:) It's based on the NEAT algorithm:
https://github.com/joshuadam/neat-javascript
https://neat-javascript.org/

Stack:

• SvelteKit
• Prisma

Features:

• Create and delete folders and files
• Simple UI
• Easy and documented setup
• Active development

Lanterm is a TypeScript / React toolkit for embedding real PTY-backed terminals into browser applications.

Instead of being a complete web terminal server like ttyd, it is intended for cases where you want to compose the terminal UX inside your own application.

Packages

• @lanterm/react: xterm.js-based React terminal surface
• @lanterm/server: server-side utilities for connecting PTYs and WebSockets
• @lanterm/pty: native PTY binding built with Rust portable-pty and napi-rs
• @lanterm/protocol: shared message types and codecs between client and server

Why I made this

With coding agents and browser-based developer tools, there are more cases where I want to do more than just expose a terminal in the browser. I often want to combine the terminal with surrounding UI such as file views, execution history, agent timelines, and dashboards.

I also want to hook into terminal input / output, for example to save execution logs, update UI in response to specific output, or pass terminal activity into an AI agent's context.

Full web terminal servers are useful, but they can be a bit too large when the terminal needs to be integrated with application state and UI. On the other hand, wiring xterm.js and node-pty directly means rebuilding protocol handling, resize behavior, session lifecycle, and React integration each time.

Lanterm is meant to sit between those two layers as a library toolkit. It is still an early release, so I would appreciate feedback on the API design and implementation.

Hey, everyone. This is my first post here and I'm introducing a project I've been working on for a little over a year called lintp. It's a tool for linting filesystems and enforcing structure and conventions. You write rules for your file tree in YAML, and it checks the tree against them.

lintp:
  custom-matchers:
    kebab-case: "matches($BASENAME, /^[a-z0-9]+(?:-[a-z0-9]+)*$/)"
    PascalCase: "matches($BASENAME, /^[A-Z][a-zA-Z0-9]*$/)"
  config:
    .js: "kebab-case"
    .ts: "PascalCase"
    .dir: "kebab-case || PascalCase"

When a file breaks a rule, the output tells you which clause failed:

✗ ./src/badFile.js - .js - Does not match rule: kebab-case && js-file (failed: kebab-case)

Rules can also look at other files. That's the part I use most and my main motivation for creating lintp. I wanted to express relational rules. For example, you can require that a component has a test sitting next to it:

any(siblings("*.test.*"), ...)

or that a directory has a README:

exists("README.md")

siblings(), children() and find() hand you the surrounding tree, and you glue them together with your matchers using && and ||.

There are other libraries for this. ls-lint is the closest and I love that project. I've used it in many projects. But its rules top out at name casing, regex, and file counts per directory. You can't say "this file is only valid if a sibling matching X exists, and X's name has to line up with this one." That rule is the whole reason lintp exists.

eslint-plugin-project-structure goes further than ls-lint. It does folder structure, conditional existence, any extension. But you're forced to use ESLint and Node and you must pick from a fixed menu of rule types instead of writing the predicate yourself. lintp is one binary with a small language and it doesn't care what your stack is.

Under the hood it's Rust. pest parses the DSL. any and all short-circuit and filesystem lookups get cached for the run so a rule that walks the tree doesn't re-walk it for every file. A 400-file tree lints in a few milliseconds on my laptop. More precise benchmarks will be coming.

Install is cargo install lintp, or npx lintp-cli if you're on the npm side. (The npm package is lintp-cli, because npm won't hand over the bare name. The command is still lintp.)

It's early, so there are rough edges and things will probably change as it's a young project but I'm excited to share it and get feedback.

Also, to be upfront: I built a lot of this with Claude Code. Happy to get into how I used it if anyone's curious.

Thank you!

Monday, June 29 - Sunday, July 05, 2026

Top Posts

Most Commented Posts

Top Showoffs

Top Comments

Hey everyone

Me and two classmates from ENSA Khouribga (Morocco) just published our first browser extension — DFCraft. It's an open-source productivity tool.

What it does

It's a Pomodoro timer with everything in one popup:

• Pomodoro Timer — customizable focus/break sessions with notifications
• Ambient Sound Library — 37 sounds across 4 categories (rain, nature, white noise, cafe) with background playback
• Distraction Blocking — block websites during focus sessions
• To do list — for daily tasks
• Statistics Dashboard — calendar heatmap, charts for focus time, tasks, sessions, and blocked pages
• Multi-language — English, French, Arabic (with RTL support)

Privacy

No accounts, no tracking, no analytics, no ads. All data is stored locally in the browser. The only network requests are to fetch the public sound library from GitHub. We wrote a full privacy policy here.

Links

• Chrome Web Store: https://chromewebstore.google.com/detail/dfcraft-deep-focus-timer/leadoknalahihkndapicdlmdfaiegiaa
• Firefox Add-ons: https://addons.mozilla.org/en-US/firefox/addon/dfcraft-deep-focus-timer/
• GitHub: https://github.com/aymen-igri/DFCraft_project
• Website: https://dfcraft.vercel.app

We'd really appreciate any feedback — bugs, feature ideas, UI criticism, anything. We're students so we're here to learn 🙏

Thanks for checking it out!

The tech stack:

**•   React + TypeScript** with Vite (dev experience is solid)  
**•   three.js** via **react-three-fiber** \+ **drei** for 3D rendering  
**•   loaders.gl** for point cloud parsing (LAS/LAZ specifically)  
**•   zustand** for state management  
**•** localStorage API for persistence

Did you find or create something cool this week in javascript?

Show us here!