What's New in Gemini 3.0

Thu, 04 Dec 2025 10:12:31 GMT

We recently shipped Gemini 3 Pro live across Google AI Studio, the Gemini app, Vertex AI, Searchs AI Mode, Google Antigravity, and more. Here is what actually shipped, how it all fits together, and what it unlocks for developers.

Copy and Paste? …in this Economy?

Sun, 02 Nov 2025 12:56:38 GMT

Astute visitors to the Eleventy Documentation will notice something new on the code blocks on the site.

A wild copy-to-clipboard component has appeared:

This feature been a long time coming and is our first use of Web Awesome on the docs (via the <wa-copy-button> custom element). Take special note of the unparalleled synergy of the Font Awesome icon used by the Web Awesome component used on the Eleventy docs.

Progressive Enhancement behavior: this is a JavaScript-only feature and has no before/without JavaScript experience. You might call this a JavaScript Web Component.
Performance-focused:
- This is using a build-time component bundle (read more about Bundling below)
- The JavaScript code for the component only loads when an instance is visible (via <is-land>)

Usage

Direct from CDN

There are a few ways to use the Copy Button component stock, with the easiest being to load the script directly from the CDN, like so (via jsdelivr):

<script type="module" src="https://cdn.jsdelivr.net/npm/@awesome.me/webawesome@3.0.0/dist-cdn/components/copy-button/copy-button.js"></script>

Or via unpkg:

<script type="module" src="https://unpkg.com/@awesome.me/webawesome@3.0.0/dist-cdn/components/copy-button/copy-button.js"></script>

Bundling

For this implementation we used esbuild to create a focused bundle for the single Web Awesome component (though this esbuild code would work for any JavaScript file).

We went with this method for improved runtime performance and to reduce the number of third-party dependencies on the web site (with a nod to André Jaenisch). You can do the same with the following bit of Eleventy configuration (e.g. in a eleventy.config.js file):

// eleventy.config.js
// don’t forget to `npm install esbuild -D`
import esbuild from "esbuild";
import { fileURLToPath } from "node:url";

async function esbuildToFile(entryPoints, outfile, options = {}) {
	return esbuild.build(Object.assign({
		entryPoints,
		platform: "browser",
		format: "esm",
		bundle: true,
		minify: true,
		banner: {
			js: `/* via ${entryPoints} */`,
		},
		outfile,
	}, options));
}

async function bundleModuleToFile(modulePath, outfile) {
	let sourcefile = fileURLToPath(import.meta.resolve(modulePath));
	return esbuildToFile([ sourcefile ], outfile);
}

export default async function(eleventyConfig) {
	let outfile = path.join(eleventyConfig.directories.output, "js/copy-button.js");

	// This will run once per build/serve/watch
	// (not with subsequent builds, save for config file changes)
	await bundleModuleToFile("@awesome.me/webawesome/dist/components/copy-button/copy-button.js", outfile);
}

Markdown Code Block Wrappers

This task also served as the impetus for fixes related to wrapper elements around code blocks in Markdown, documented in a previous blog post on this very web site.

Testing the untestable

Thu, 30 Oct 2025 20:57:58 GMT

I’m currently working on a software designed more than a decade ago. It offers a plugin architecture: you can develop a plugin whose lifecycle is handled by the software. The tough part, though, is how you access the platform capabilities: via static methods on singletons. @Override public boolean start() { var aService = AService.getInstance(); var anotherService = AnotherService.getInstance(); // Do something with the services var result = ...; return result; } T

Look Out For Bugs

Sun, 12 Oct 2025 12:34:28 GMT

One of my biggest mid-career shifts in how I write code was internalizing the idea from this post: Don't Write Bugs

Some thoughts on LLMs and Software Development

Mon, 22 Sep 2025 20:35:34 GMT

a short post

Architecting with Constraints: A Pragmatic Guide

Sat, 23 Aug 2025 14:23:03 GMT

Don't just reach for your favorite framework. Let's explore how a constraint-based mindset can help you choose the right tool for the job and avoid over-engineering.

Curated by community on the bookmarksfor.dev