DEV Community: TechRay.dev

How to Enable the Gemini Sidebar in Chrome on Linux

Raymond Busuttil — Thu, 29 Oct 2026 01:32:19 +0000

Want to use Google's Gemini AI directly inside Chrome on Linux? You may be able to enable Chrome's built-in Gemini integration by changing an experimental browser flag.

The feature, internally known as Glic, can enable Gemini integration in Chrome, including a sidebar-style experience on supported configurations. Here's how to try it on your Linux desktop.

Step 1: Open Chrome Flags

Launch Google Chrome and enter the following address in the address bar:

chrome://flags

Press Enter to open Chrome's experimental features page.

Step 2: Find the Glic Flag

In the search box at the top of the page, type:

Glic

Look for the flag named Enables glic, with a description indicating support for Mac, Windows, Linux, ChromeOS, and Android.

You can also navigate directly to the flag using this link:

chrome://flags/#glic

Step 3: Enable Glic

Locate the dropdown menu next to the Enables glic option.

Click the dropdown menu.
Select Enabled.
Leave the other flags unchanged for now.

This activates the experimental Glic feature flag in your Chrome configuration.

Step 4: Relaunch Chrome

After enabling the flag, Chrome will display a Relaunch button at the bottom of the page.

Click Relaunch to restart the browser and apply the change.

Save any unfinished work in your open tabs before restarting.

Step 5: Open Gemini in Chrome

Once Chrome restarts, look for a Gemini button or other Gemini entry point in the browser interface.

If the integration is available for your Chrome version and account, you may be able to open Gemini alongside the webpage you're viewing.

This makes it easier to ask questions about a page, get help with research, and use AI without constantly switching between tabs.

Troubleshooting: Gemini Sidebar Still Missing?

If enabling Glic doesn't make the Gemini button or sidebar appear, try the following:

Check your Chrome version: Update Chrome to the latest version available for your Linux distribution.
Look for related flags: Search chrome://flags for Glic side panel. If that option exists, try enabling it and relaunching Chrome.
Check Chrome settings: If available, look under Settings → AI innovations → Gemini in Chrome for options to show the Gemini button.
Remember that flags are experimental: Enabling Glic does not guarantee that the complete Gemini interface will appear. Availability can depend on your Chrome build, account, region, and Google's rollout.

It's easy, but shouldn't be a chore

Getting Gemini integrated into Chrome on Linux may be as simple as enabling the Glic flag and restarting your browser. However, the flag alone may not unlock every part of the experience on every Linux installation.

If it works on your setup, you'll have a convenient way to bring Google's AI closer to your everyday browsing workflow without leaving Chrome.

The Animated Component Library You Copy, Own, and Make Your Own

Raymond Busuttil — Tue, 20 Oct 2026 07:05:35 +0000

Here's the dirty secret of modern front-end development: most websites look the same. Same hero layout, same fade-in-on-scroll, same stock card grid. And now that AI coding tools can generate a working page in minutes, the sameness is getting worse — everything is functional, clean, and completely forgettable.

The difference between a page people scroll past and a page people remember usually isn't the layout. It's motion, texture, and detail — the animated headline, the background that feels alive, the button that responds like it noticed you. Those are also exactly the things that take the longest to build by hand.

That's the gap React Bits fills. It's a free, open-source library of animated React components and backgrounds that you copy into your project and make your own — and it's become one of the easiest ways to give a site a designed, hand-crafted feel without spending days on animation code.

What React Bits actually is

React Bits is a collection of 135+ animated building blocks, organized into five categories:

Text Animations — SplitText, BlurText, GlitchText, DecryptedText, ShinyText, RotatingText, and dozens more ways to make a headline earn attention
Animations — interaction and motion pieces like Magnet, SplashCursor, ClickSpark, ImageTrail, and GlareHover
Components — full UI elements with personality: SpotlightCard, TiltedCard, Dock, GooeyNav, CircularGallery, MagicBento, Masonry
Backgrounds — full-page animated scenes you drop behind your content: Aurora, Particles, Galaxy, LiquidChrome, Beams, Hyperspeed, Silk
Micro Interactions — the small, satisfying details that separate a polished interface from a plain one

The philosophy is copy-and-own, the same idea that made shadcn/ui so popular. You don't install React Bits as a package and then fight its defaults with overrides. You take the component's source code, drop it into your project, and from that moment it's your code. Change the colors, rewrite the easing, delete the parts you don't need — no library update will ever break your changes, because there's no library dependency to update.

For developers who've wrestled with heavyweight component suites — importing an entire framework just to use three pieces of it, then spending an afternoon overriding styles — this model is a relief. Your bundle only contains what you actually picked, in the form you actually want it.

Four flavours of everything

One of the smartest decisions in React Bits is that every component ships in four variants:

JavaScript + CSS
JavaScript + Tailwind
TypeScript + CSS
TypeScript + Tailwind

The install name tells you which one you're getting — it ends with the flavour, like SplitText-TS-TW for the TypeScript + Tailwind version. So if your project runs TypeScript and Tailwind, you never have to convert plain CSS by hand or strip types out of a .tsx file. The component arrives already speaking your stack's language.

Installing one is a single command through the shadcn CLI:

npx shadcn@latest add @react-bits/SplitText-TS-TW

Prefer doing it manually? Every component page shows the full source with a code tab — open it, pick your flavour, and paste the files into your project. Both paths end the same way: real source code in your repo, ready to edit.

The pieces worth knowing first

With 135+ components, nobody needs all of them. These are the ones that tend to earn their place:

SplitText is the library's signature piece — it breaks a headline into individual characters or words and animates them in with a springy stagger. It's the fastest way to make a hero section feel expensive.

Aurora and Particles are the background workhorses. Aurora gives you those soft, northern-lights gradients drifting behind your content; Particles gives you a field of floating dots that can react to the mouse. Either one turns a flat hero section into a scene.

SpotlightCard is a card with a radial glow that follows the cursor — you've seen this effect on high-end product sites, and it's the kind of thing that takes an evening to build well from scratch. Here it's a copy-paste.

Dock recreates the macOS dock magnification effect for navigation or icon rows, and GooeyNav does navigation with a liquid, morphing indicator. Both are pure personality.

DecryptedText scrambles characters that resolve into the real text — perfect for anything tech-flavored — while CountUp handles the animated number counters every stats section wants.

The pattern across all of them: these are effects people notice, that are genuinely fiddly to build correctly (springs, easing curves, intersection observers, cleanup), and that arrive here already built and tunable.

More than components: the free tools

React Bits also ships a set of browser-based tools that are useful even outside the library:

Background Studio — browse every animated background, start from a preset, and tune it live. Export as code, a high-resolution image, or a looping MP4/WebM video.
Center Stage — turn a screenshot or screen recording into a polished product shot on lifelike phones, laptops, and browser frames, with 3D tilt, depth of field, and shadows. Great for launch posts and demos.
Shape Magic — design a logo mark from shapes, patterns, text, or your own SVG, then finish it with a 3D material like chrome, glass, or neon. Exports SVG, PNG, favicons, even video.
Texture Lab — run photos, video, or your camera through 160 one-click styles and 75+ stackable effects, from ASCII and halftone to glass, chrome, and glitch.
Sound Lab — a library of polished interface sounds, from soft taps and toggles to risers and whooshes, tunable and exportable as WAV, MP3, or OGG.

For a solo developer or a small studio, that's a surprising amount of production value sitting in one free ecosystem.

The fine print

React Bits is free for personal and commercial work under the MIT + Commons Clause license. Use the components in any app, website, or product — the one thing you can't do is sell, sublicense, or redistribute the components themselves as a library. For anyone building client work or products, that's an easy line to respect.

Not on React? Official ports exist for Vue and Svelte, so the library isn't a React-only club. And the project is active and community-driven — contributions are welcome, and it reaches over 500K developers a month, which is a decent signal that it's not disappearing next quarter.

A fair caveat: animation is seasoning, not the meal. Stacking six animated backgrounds and a custom cursor on one page will hurt performance and annoy visitors. The developers who get the most out of React Bits pick two or three pieces per page and tune them to match the brand — the library makes that easy precisely because the code is yours to trim.

The bottom line

Most component libraries sell you structure: grids, forms, buttons, modals. React Bits sells you the layer on top of structure — the motion and texture that make a site feel designed instead of generated. It's free, it's copy-and-own, it speaks JavaScript or TypeScript with CSS or Tailwind, and the install takes one command.

If your projects have been coming out clean but forgettable, spend ten minutes browsing reactbits.dev. Grab a SplitText headline, an Aurora background, and a SpotlightCard or two — and watch how fast "functional" turns into "memorable."

How to Generate Images in Claude Code (2026)

Raymond Busuttil — Sun, 18 Oct 2026 21:32:15 +0000

Claude Code is fantastic at writing code, fixing bugs, and explaining things. But ask it to draw you a picture and it'll politely tell you it can't — it's a text-based tool with no built-in image generation.

Here's the good news: you can teach it. In about ten minutes, you can set Claude Code up with a third-party image API, and from then on you just say "generate an image of a sunset over mountains" and it handles everything. Your API key stays tucked away in a file Claude reads but never repeats back to you.

We'll use Google's Gemini API as our example in this guide, but nothing here is Gemini-specific — OpenAI, Stability AI, Replicate, or any other image API with an HTTP endpoint works exactly the same way. Swap the key and the endpoint, keep everything else.

This guide assumes you've never done anything like this before. Let's go step by step.

What You'll Need

Three things:

Claude Code installed and working (if you can open it and chat, you're good)
An API key for an image generation API — we'll use Google's Gemini in this guide, but any provider works
A project folder — any folder where you run Claude Code

That's it. No complicated setup.

Step 1: Get Your Gemini API Key

Google's Gemini API can generate images. To use it (or any other provider — the steps are the same idea everywhere: sign up, create a key, copy it):

Go to aistudio.google.com and sign in with your Google account.
Click Get API Key (usually in the left sidebar or top menu).
Click Create API Key. Google will generate a long string of letters and numbers — that's your key.
Copy it somewhere safe for the next two minutes. You'll paste it into a file in the next step, then you won't need to look at it again.

A note on pricing: Google AI Studio has historically offered a free tier, but what's included can change — check their current pricing page to confirm image generation is covered before you start generating dozens of images. The same goes for any provider: know what each image costs you before you scale up.

Treat this key like a password. Anyone with your key can generate images on your dime (or burn through your free quota). You'll never paste it into a chat window — not even to Claude.

Step 2: Create Your .env File

A .env file is just a plain text file that holds secrets like API keys. Programs read it; humans rarely open it. Keeping your key here instead of in your code or chat history is standard practice.

In your project folder (the same folder where you run Claude Code), create a file called exactly .env — nothing before the dot.
Open it in any text editor and add one line:

GEMINI_API_KEY=your-actual-key-goes-here

Replace your-actual-key-goes-here with the key you copied from AI Studio. No quotes, no spaces around the equals sign.

Save the file.

One more critical step: if your project uses git, make sure .env never gets committed. Create (or open) a file called .gitignore in the same folder and add this line:

.env

That's it. Your key now lives in one place, out of your code and out of your chat history.

Step 3: Tell Claude Code About Your Setup

Here's where the magic happens. Open Claude Code in your project folder and send it a message like this:

I put my Gemini API key in the .env file in this project as GEMINI_API_KEY. From now on, whenever I ask you to generate an image, use that key with the Gemini image generation API to create it. Read the key from the .env file yourself — never ask me for it, and never print it, display it, or paste it into the chat.

That's the whole instruction. You're establishing three rules:

Where the key lives — in .env, under the name GEMINI_API_KEY.
What to do with it — use it for image generation whenever you ask.
What never to do with it — show it to you or anyone else.

Claude Code will confirm it understands. From this point on, the setup is permanent for this project — you only do this once.

Optional: Make It Permanent with CLAUDE.md

If you want this to survive across sessions without re-explaining, add the same instruction to a CLAUDE.md file in your project root. Claude Code reads this file automatically every time it starts. Just create CLAUDE.md and write:

## Image Generation

- The Gemini API key is stored in `.env` as `GEMINI_API_KEY`.
- When I ask for an image, generate it using the Gemini image API
  (model `gemini-3.1-flash-image`) with that key.
- Never display, repeat, or log the API key.

Now every future Claude Code session in this folder knows the deal from the start.

Step 4: Generate Your First Image

Just ask. Try something like:

Generate an image of a cozy cabin in the woods at sunset, warm light in the windows.

Claude Code will get to work. Here's roughly what happens behind the scenes:

It reads your .env file to get the key (silently — you won't see the key).
It writes a small script that calls the Gemini API with your prompt.
It runs the script, which sends your prompt to Google's image model.
It saves the resulting image into your project folder (usually as a .png file) and tells you where it is.

A few seconds later, you'll have an actual image file sitting in your folder. Open it and take a look.

Want another? Just keep asking:

Now generate a logo concept for a coffee shop called "Moonbeam Roasters" — minimalist, crescent moon, warm browns.

Each image lands in your project folder, ready to use.

How It Works Under the Hood

You don't need to understand this to use it, but it's nice to know what's happening — and it demystifies why this approach is so flexible.

When you ask for an image, Claude Code typically writes a short Python script that looks something like this:

import os
import base64
import requests
from dotenv import load_dotenv

load_dotenv()
api_key = os.getenv("GEMINI_API_KEY")

response = requests.post(
    "https://generativelanguage.googleapis.com/v1beta/models/"
    "gemini-3.1-flash-image:generateContent?key=" + api_key,
    headers={"Content-Type": "application/json"},
    json={
        "contents": [{"parts": [{"text": "a cozy cabin in the woods at sunset"}]}],
        "generationConfig": {"responseModalities": ["IMAGE"]},
    },
)

data = response.json()
for part in data["candidates"][0]["content"]["parts"]:
    if "inlineData" in part:
        with open("cabin-sunset.png", "wb") as f:
            f.write(base64.b64decode(part["inlineData"]["data"]))

The script loads your key from .env, sends your prompt to Gemini's image model, gets back image data, and saves it as a PNG. Claude handles all of this for you — you'll usually never need to write or even look at this code. But now you know there's no magic involved, just an API call.

The beauty of this setup: it works with any image API, not just Gemini. If you'd rather use OpenAI's image model, Stability AI, or anything else with an HTTP API, the same pattern applies — key in .env, instruction to Claude, done.

Your API Key Stays Safe

This deserves its own section because it's the part beginners worry about most — rightly so.

Here's what protects your key in this setup:

It's in .env, not in chat. You never typed the key into Claude Code. Claude read it from the file directly.
Claude was told never to display it. The instruction in Step 3 (or your CLAUDE.md) explicitly forbids printing the key. Claude respects this — it will use the key silently in API calls without ever echoing it.
.gitignore keeps it out of version control. If you push your project to GitHub, the .env file stays on your machine.

One thing to watch: if you ever ask Claude to "show me the script you used," the script it shows you will reference os.getenv("GEMINI_API_KEY") — the variable name, not the actual key. That's exactly what you want.

Tips for Better Images

Once the basics work, these small habits make a big difference:

Be specific in your prompts. "A dog" gives you a generic dog. "A watercolor painting of a golden retriever puppy sleeping in a sunbeam, soft brushstrokes" gives you something you'll actually want to keep.
Mention style. Photorealistic, cartoon, oil painting, pixel art, minimalist logo — the model follows style cues well.
Ask for variations. "Give me three versions of this" works fine. Claude will generate them one after another.
Iterate. Don't like the result? Say what to change: "same thing but at night" or "make it wider, more like a banner." Each round is a new API call.
Name your files. "Save this one as hero-banner.png" keeps your folder organized instead of filling up with generic names.

Troubleshooting

"Claude says it can't find the key." Make sure the .env file is in the same folder where you're running Claude Code, and that the variable is named exactly GEMINI_API_KEY (all caps, underscores). Check for typos and stray spaces.

"The API returns an error." The most common cause is an invalid or expired key. Go back to AI Studio, generate a fresh key, and update your .env. Also check your usage against your plan's quota — if you've hit a limit, that's your culprit.

"The image looks wrong." That's a prompting issue, not a setup issue. Try describing what you want in more detail — subject, style, lighting, mood. Image models are literal; they draw what you describe.

"Claude printed my key!" This shouldn't happen if you gave the instruction from Step 3. If it ever does, immediately go to AI Studio and revoke/regenerate your key, update .env, and remind Claude of the rule.

Wrapping Up

That's the whole setup: key from AI Studio, one line in .env, one instruction to Claude Code. Ten minutes of setup, and from then on generating images is as easy as describing what you want.

What I love about this approach is that nothing is locked in. Swap Gemini for another provider later? Just change the key and tell Claude which API to call. The pattern — secrets in .env, instructions in plain English — works for any API you want Claude Code to use, not just image generation.

Now go make something. Start with that cabin at sunset.

How to Get 1 Billion Free Muse Tokens

Raymond Busuttil — Mon, 12 Oct 2026 17:02:38 +0000

New Muse users can get 1 billion free tokens by entering an invite code in Settings within 48 hours of signing up. That is roughly ten weeks of the free weekly allowance, at no cost and with no card required.

If you have been curious about Muse, Meta's new personal AI agent, this guide explains what it is, what it can do, how its tokens work, and exactly how to claim the bonus. You can use my invite code below:

Muse invite code: 02F1OY
Sign up:          https://muse.ai/join

What is Muse?

Muse is a personal AI agent that Meta launched on September 8, 2026. Unlike a chatbot that only answers questions, Muse is built to take action and get things done on your behalf.

It runs on Muse Spark, which Meta calls its most capable model to date and which it designed for real-world agent tasks. You talk to it the way you would text a friend, either in the Muse app or through WhatsApp.

A few things set it apart:

Its own computer. Each Muse agent runs on a private cloud virtual machine (Meta calls it Muse Secure VM) with its own storage and a full web browser you can watch.
It keeps working. Long tasks continue in the background even after you close the app.
It's personal. You can name your agent, give it an avatar, and choose how it communicates.
Availability. Muse is rolling out in the United States for adults 18 and older, on iOS, Android, and the web at muse.ai. Support for Meta's AI glasses is planned.

What Muse can do for you

Muse handles both quick errands and long-running goals. According to Meta and launch coverage, it can:

Send emails and manage your calendar
Book travel and make reservations
Open a browser, fill out forms, and complete online checkouts
Negotiate on your behalf, for example to lower a bill or sell a car
Take a bigger goal, turn it into a personal plan, and keep working on it over days or weeks
Offer proactive suggestions as it learns what matters to you

You decide which apps it can connect to, such as email, calendar, payments, and shopping, and you can revoke access at any time. Meta also says Muse is the first AI agent covered by Link's purchase protections, including coverage for lost or damaged items and no-fee returns on eligible purchases.

A few practical ideas to try first:

"Find three flights to Chicago next month under $250 and hold the best one for my approval."
"Compare my internet plan to what's available at my address and draft a message asking for a lower rate."
"Plan a weekly meal schedule and build a grocery list for it."

How Muse tokens and plans work

Muse is free to use up to a weekly limit, and everything is metered in tokens rather than messages. Tokens are the small chunks of text the model reads and writes as it plans, browses, and fills in forms, so one long background task can use far more than a dozen quick questions.

Plan	Price	Weekly allowance
Free	$0	About 100 million tokens (reported)
Power	$20/month	500 million tokens
Max	$100/month	3 billion tokens

The free figure comes from Meta's announcements and third-party testing; check Meta's help page for the current numbers. When you hit your limit, Muse pauses until the weekly reset or until you upgrade.

Invite bonus tokens sit on top of your weekly allowance, which is why claiming them early is worth it.

How to get 1 billion free Muse tokens, step by step

The whole process takes about two minutes. The only rule that matters: redeem the code within 48 hours of creating your account, because the option disappears after that.

Create your account. Go to muse.ai/join or download the Muse app on iOS or Android. On the web you sign in with a phone number and a Meta account, then complete age verification.
Open Settings. On the web, click the gear icon in the lower left. In the app, open the menu and tap Settings.
Find Redeem Invite Code. It usually sits under General (on some versions, General then Usage).
Enter the code 02F1OY and tap Confirm.
Check your balance. Make sure the 1 billion bonus tokens show up before you close Settings.

That's it. You get 1 billion tokens, and so do I, as a thank-you for the referral.

Check out Muse, your personal AI agent. Redeem my code in Settings
within 48 hours of joining and we'll both get 1 billion Muse tokens.

Code: 02F1OY
https://muse.ai/join

Tip: Once you're in, you get your own invite code too (look for the Invite button). Each account can reportedly refer up to 20 friends, earning 1 billion tokens per successful invite.

What 1 billion tokens is actually worth

One billion tokens equals about ten weeks of the free weekly allowance, or two full weeks of the $20 Power plan.

Comparison	Equivalent of 1B bonus tokens
Free plan (~100M/week)	About 10 weeks
Power plan (500M/week)	About 2 weeks
Max plan (3B/week)	About 2 days

In practical terms, that is room to let Muse run real errands, research projects, and longer background goals without watching the meter. Agent tasks that browse many pages burn tokens faster than chat, so the bonus is most useful for the bigger jobs.

Privacy and safety: what to know before you connect your accounts

An agent that reads your email and makes purchases needs more trust than a chatbot, and Meta has built in several safeguards:

Isolated machine. Your agent and your data live in their own virtual machine that no other user's agent can reach.
Sentinel. A separate security agent controls internet access and permissions, kept apart from Muse at the system level.
Hidden credentials. Passwords and payment details are stored so Muse itself never sees them.
Your choice on training. You can opt out of having your conversations used to train Meta's models, and Meta says personal conversations aren't shared with its advertising systems.

Good habits still apply. Start by connecting only the apps a task needs, require approval for purchases, and review what Muse did before you hand it more access.

Frequently asked questions

Is Muse really free? Yes. The free tier has the same features as the paid plans, just a smaller weekly token allowance.

Do the bonus tokens expire? Bonus tokens are separate from your weekly allowance and don't reset with it. Meta can change promotion terms, so use them on real tasks rather than saving them indefinitely.

I missed the 48-hour window. Can I still redeem? No. The redeem option disappears once the window closes, so enter the code during your first session.

Can I use Muse outside the US? Not officially yet. An invite code only adds tokens; it doesn't unlock Muse in countries where it hasn't launched.

Is Muse the same as Muse Code or the Meta AI app? No. Muse Code is a separate coding tool for developers with its own plans, and Meta AI is Meta's general assistant.

Ready to try it?

Sign up at muse.ai/join, open Settings, and redeem code 02F1OY within 48 hours. You'll start with 1 billion bonus tokens on top of your free weekly allowance.

Welcome to TechRay.dev: Why I'm Writing About AI, Agents, and the Future of Building Software

Raymond Busuttil — Thu, 24 Sep 2026 00:05:56 +0000

Hi, I'm Raymond Busuttil, and this is the first post on my new corner of the internet.

I've wanted a place like this for a while. Tech moves fast, and the last couple of years have felt like a decade of change compressed into a few seasons. I spend a lot of time reading, tinkering, and building with the latest tools, and I kept catching myself explaining the same things to friends and colleagues over and over. A personal site felt like the obvious next step: a place to think out loud, share what I learn, and hopefully save you some time along the way.

What TechRay.dev is about

Three things will show up here more than anything else:

Trending tech. I'll cover the tools, platforms, and shifts that are worth paying attention to, and I'll be upfront about the ones I think are overhyped.

AI, practically speaking. Not the breathless "everything is about to change" version, and not the dismissive "it's just autocomplete" version either. I want to look at what these systems are genuinely good at, where they fall over, and how to use them well in real work.

Agentic coding. This is the one I'm most excited about. We've moved from AI that suggests the next line of code to AI that can plan a task, read a codebase, run commands, fix its own errors, and hand back a working result. That changes how software gets built, and it changes what it means to be a developer.

Opinion, with receipts

Expect two flavors of content on this blog.

The first is opinion pieces. I have views, sometimes strong ones, and I'll share them. But I'll try to hold them loosely. If I change my mind about something, I'll say so, because in a field that reshapes itself every few months, the people who never update their opinions are the ones who get left behind.

The second is helpful, hands-on articles: how-tos, workflows, lessons learned, and the occasional "here's the mistake I made so you don't have to." If a post doesn't leave you with something you can use or think about, I haven't done my job.

A quick take on agentic coding

Since it's going to be a recurring theme, here's where my head is at right now.

The biggest shift isn't that AI can write code. It's that AI can now work on code. There's a real difference. Autocomplete helps you type faster. An agent can take a goal like "add pagination to this endpoint and update the tests," explore your project, make changes across several files, run the test suite, notice something broke, and try again.

That's powerful, and it's also where people get into trouble. A few things I've come to believe:

Your judgment matters more, not less. When code is cheap to generate, the scarce skill becomes knowing what to build, spotting what's subtly wrong, and deciding what "good" looks like.
Review is the new bottleneck. Agents can produce changes faster than a human can carefully read them. Learning to review efficiently, and to structure work so it's reviewable, is a real skill.
Clear instructions beat clever prompts. The people getting the best results aren't using magic phrases. They're giving agents clear context, tight scope, and a way to verify their own work, like tests or a build step.
Small, verifiable steps win. Asking an agent to rebuild your whole app in one go is a gamble. Asking it to do one well-defined piece and confirming it works is how you make steady progress.
Fundamentals still pay off. Understanding how systems work, how to debug, and how to read code makes you a far better collaborator with an AI than someone who's just accepting whatever comes back.

I don't think agents replace developers. I do think developers who learn to work with them will have a serious edge, and I want to help make that transition less intimidating.

The healthy skepticism clause

I'm optimistic about this technology, but optimism isn't the same as cheerleading. AI tools make mistakes, sometimes confidently. They can introduce security problems, invent APIs that don't exist, and produce code that looks right but isn't. Hype cycles also tend to skip over the boring stuff: cost, reliability, maintenance, and the impact on people's jobs and careers.

I'll try to cover the full picture here, the exciting parts and the uncomfortable ones. If something is impressive, I'll say so. If it's a shiny distraction, I'll say that too.

What's coming next

To give you a taste of what's ahead, here are some topics I'm planning to dig into:

How I set up my workflow for building with AI coding agents
Common mistakes people make when delegating work to an agent (and how to avoid them)
What to look for when choosing between AI tools and models
How to keep your own skills sharp while leaning on AI
Honest reviews of new tools and releases as they land

If there's something specific you'd like me to cover, I'd genuinely love to hear it. This site will be better if it's shaped by the people reading it.

Thanks for being here

Whether you're a seasoned engineer, a curious beginner, or just someone trying to make sense of where technology is heading, I'm glad you stopped by. I'm figuring this out as I go, and I'd like to do it in public, with you along for the ride.

Grab a coffee, look around, and check back soon. There's a lot to explore.

Until next time,
Raymond Busuttil
TechRay.dev