Tag Archives: technology

Is coding over? My prediction…

We Are About to Let AI Write 90% of Our Code

Hi friends 👋

In the last two months, something has changed.

And I don’t mean incrementally. I mean, fundamentally.

If you’ve tried using Claude Code with Opus — or accessed the Opus model through another provider — you can feel it. This is no longer autocomplete on steroids. This is something different.

This is real.
And it’s starting to work really well.

My Prediction

I’m not sure you’ll agree with me, but here it goes:

Within the next 2–3 years, 90% of the code we ship will be AI-generated.

Our job as developers will shift dramatically.

Instead of writing most of the code ourselves, we’ll focus on:

Providing high-quality context
Managing complexity and moving pieces
Handling edge cases AI can’t infer
Connecting systems
Making architectural decisions
Ensuring business value is delivered

In short, we’ll move from being writers of code to being managers of AI agents.

Almost like engineering managers — but for agents.

From Autocomplete to Agents

The early days of AI in development were about better tab-complete.

That era is over.

It’s time to “leave the seat” to AI agents — or even multiple agents working together — and step into a different role:

Making sure priorities are correct
Deciding which models to use and when
Managing cost (because yes, this can get expensive)
Ensuring output quality
Validating real-world impact

This year, I think we’ll learn a lot about how to be efficient in this new paradigm.

If You Don’t Believe It…

Try Claude Code with Opus.

That’s my honest recommendation. It’s what I’ve been using over the past two weeks, and it genuinely opened my eyes.

Other models can work too — Codex latest versions are solid — but not all models feel the same. Some are useful, but don’t yet deliver that “this changes everything” moment.

Opus does.

New Challenges Ahead

Of course, this shift brings new problems:

What happens to pull requests?

If most of the code is AI-generated, what exactly are we reviewing?

What about knowledge depth?

If you’re not writing the code, are you really understanding it?

This is critical.

You don’t want to be on call at 3AM, debugging production, and only knowing how to “prompt better.”

We are not at the point where programming becomes assembly and English becomes the new C.

We are far from that.

You still need to understand what’s happening. Deeply.

The 90/10 Rule

I think we’ll see something like a Pareto distribution:

90% of code: AI-generated
10% of code: Human-crafted

That 10% will matter a lot.

It will involve:

Complex context
Architectural glue
Edge cases
Critical logic
Irreducible human judgment

Development isn’t disappearing.

But it is transforming.

Exciting Times (Depending on Why You’re Here)

If you love building, solving problems, designing systems — this is an incredibly exciting time.

If what you loved most was physically typing every line of code yourself…

That part is changing.

I’m optimistic.

I think software development is evolving, not dying.

But the role of the developer?
That’s definitely being rewritten.

Let me know what you think.

See you 👋

Free Auto Silence Remover / Slicer – Remove Silence from Videos Automatically

Removing Silences from Videos with a Free Open-Source Tool (Local + Vercel Deployment)

Hi friends 👋
In this post, I want to show you the free, open-source tool I currently use to remove silences from my videos. We’ll walk through how it works locally, explore its UI and internals, and finally deploy it to Vercel so you can run it as a hosted solution.

If you create YouTube videos, podcasts, or tutorials, this tool can save you a lot of editing time.

Running the Project Locally

I’m starting directly from the repository. This is a Node.js project, and running it locally is straightforward:

yarn run dev

Once executed, the app runs on a local port and spins up a development server. The local UI is slightly different from the currently hosted version, which makes it ideal for experimentation and debugging.

Analyzing a Video (Silence Detection)

After the app is running, you can simply drag and drop a video file into the interface. I tested it with my previous video about Moises.ai, and the analysis was surprisingly fast.

To better understand what’s happening behind the scenes, I opened the developer tools. You can clearly see FFmpeg being loaded and network activity kicking in while the analysis runs.

Tweaking Detection Parameters

One of the best things about this tool is how configurable it is:

Mean volume – controls how quiet a segment must be to count as silence
Minimum silence duration – adjusts how long silence must last to be removed

After tweaking these values and clicking Analyze again, you’ll notice different results. Once finished, the app tells you the new duration of the video after silence removal.

Exporting the Result

When you’re happy with the analysis, you can:

Export the processed video
Export the timeline (useful for further editing)

At this point, everything is handled locally through FFmpeg, without uploading your video anywhere — a big plus for privacy.

Working with the Timeline UI

The UI is honestly one of the highlights of this project.

You get a visual timeline where silence regions are clearly marked. From here you can:

Add zones manually
Click Zone Add and select the part you want to include or modify.
Remove zones manually
Click Zone Delete and simply select the sound you want to remove.

You can immediately play back the result to verify that everything works as expected — and it does, really well.

Deploying to Vercel

Next, I wanted a hosted version, so I deployed the project to Vercel.

Steps:

Go to your Vercel dashboard
Click Import Project
Vercel detects it as a Node.js project automatically
Deploy with default settings

At first, I ran into a deployment error. After copying the error message into ChatGPT and applying a small fix, the deployment worked perfectly.

Once deployed, the app behaves exactly the same as the local version — but now it’s available online under my own Vercel URL.

Quick Look at the Codebase

Since we had some extra time, I explored the code to understand how silence removal actually works.

Tech Stack Overview

Node.js
UI built with a React-like framework
FFmpeg running in the browser
WaveSurfer.js for waveform visualization

Key Components

VideoEditor component
Timeline / waveform component
Silence detection logic in the video renderer

How Silence Detection Works

The core logic happens in a helper responsible for silence analysis:

It uses WaveSurfer.js with the Regions plugin
Regions are automatically extracted based on silence
The analyzeRegions helper:
- Extracts regions
- Filters them by silence thresholds
- Produces the final list of segments to keep

FFmpeg is then called with the correct parameters to stitch together only the non-silent parts.

Simple, elegant, and very effective.

Final Thoughts

This tool is a great example of how powerful open-source projects can be when combined with modern web tech. It’s fast, private, configurable, and easy to deploy.

If you edit videos regularly, I highly recommend checking it out and even self-hosting it like I did.

See you in the next video 👋

Exploring Steganography with Hidden Unicode Characters

1 Reply

In the digital age, where information security is paramount, steganography has emerged as a fascinating and subtle method for concealing information. Unlike traditional encryption, which transforms data into a seemingly random string, steganography hides information in plain sight. One intriguing technique is the use of hidden Unicode characters in plain text, an approach that combines simplicity with stealth.

What is Steganography?

Steganography, derived from the Greek words “steganos” (hidden) and “graphein” (to write), is the practice of concealing messages or information within other non-suspicious messages or media. The goal is not to make the hidden information undecipherable but to ensure that it goes unnoticed. Historically, this could mean writing a message in invisible ink between the lines of an innocent letter. In the digital realm, it can involve embedding data in images, audio files, or text.

The Role of Unicode in Text Steganography

Unicode is a universal character encoding standard that allows for text representation from various writing systems. It includes many characters, including letters, numbers, symbols, and control characters. Some of these characters are non-printing or invisible, making them perfect for hiding information within plain text without altering its visible appearance.

How Does Unicode Steganography Work?

Unicode steganography leverages the non-printing characters within the Unicode standard to embed hidden messages in plain text. These characters can be inserted into the text without affecting its readability or format. Here’s a simple breakdown of the process:

Choose Hidden Characters: Unicode offers several invisible characters, such as the zero-width space (U+200B), zero-width non-joiner (U+200C), and zero-width joiner (U+200D). These characters do not render visibly in the text.
Encode the Message: Convert the hidden message into a binary or encoded format. Each bit or group of bits can be represented by a unique combination of invisible characters.
Embed the Message: Insert the invisible characters into the plain text at predetermined positions or intervals, embedding the hidden message within the regular text.
Extract the Message: A recipient who knows the encoding scheme can extract the invisible characters from the text and decode the hidden message.

Example: Hiding a Message

Let’s say we want to hide the message “Hi” within the text “Hello World”. First, we convert “Hi” into binary (using ASCII values):

H = 72 = 01001000
i = 105 = 01101001

Next, we map these binary values to invisible characters. For simplicity, let’s use the zero-width space (U+200B) for ‘0’ and zero-width non-joiner (U+200C) for ‘1’. The binary for “Hi” becomes a sequence of these characters:

H: 01001000 → U+200B U+200C U+200B U+200B U+200C U+200B U+200B U+200B
i: 01101001 → U+200B U+200C U+200C U+200B U+200C U+200B U+200B U+200C

We then embed this sequence in the text “Hello World”:

H\u200B\u200C\u200B\u200B\u200C\u200B\u200B\u200B e\u200B\u200C\u200C\u200B\u200C\u200B\u200B\u200C llo World

To the naked eye, “Hello World” appears unchanged, but the hidden message “Hi” is embedded within.

Advantages and Disadvantages

Advantages:

Subtlety: The hidden information is invisible to the casual observer.
Preserves Original Format: The visible text remains unaltered, maintaining readability and meaning.
Easy to Implement: Inserting and extracting hidden characters is straightforward with proper tools.

Disadvantages:

Limited Capacity: The amount of data that can be hidden is relatively small.
Vulnerability: If the presence of hidden characters is suspected, they can be detected and removed.
Dependence on Format: Changes in text formatting or encoding can corrupt the hidden message.

Practical Applications

Secure Communication: Concealing sensitive messages within seemingly innocuous text.
Watermarking: Embedding copyright information in digital documents.
Data Integrity: Adding hidden markers to verify the authenticity of text.

Conclusion

Unicode steganography in plain text with hidden characters offers a clever and discreet way to conceal information. By understanding and utilizing the invisible aspects of Unicode, individuals can enhance their data security practices, ensuring their messages remain hidden in plain sight. As with all security techniques, it’s essential to stay informed about potential vulnerabilities and to use these methods responsibly.