Forem: Sleeyax

AI is changing what I build

Sleeyax — Thu, 02 Apr 2026 19:29:21 +0000

How AI is changing not just how fast I build, but what I build, and why that matters for everyone who’s ever had a small idea.

TL;DR

AI coding tools don’t just make developers faster. They lower the bar for which ideas are worth building. That means more niche, personal, and practical software gets made. Here’s how that shift looks in practice, and why it matters.

Intro

The biggest change AI has brought to how I build software is not that it makes me faster at writing code.

It changes which ideas are worth building at all.

I’m a professional software developer, so turning an idea into code was never the hard part. The real constraint was whether I cared enough to spend the time. Countless small ideas never made it past that filter. Not because they were bad, but because they weren’t important enough to justify the setup cost, implementation work, and mental overhead of yet another side project.

That’s what feels different now.

There’s a whole category of apps I used to mentally discard: useful, narrow, personal tools that solve one annoying problem, but not enough to earn a weekend of focused work. Those ideas died in the gap between “this would be nice to have” and “I’m actually willing to build it.”

With AI coding tools, that gap is much smaller, and shrinking.

Now, I can take an idea that would have stayed a note in my head, bootstrap it in a couple of hours, iterate quickly, and decide after seeing a working version whether it deserves more attention. The economics of building have changed. The threshold for trying something new has dropped.

That doesn’t mean the work disappears. I still need to decide what I want, review what gets produced, test it, and cut scope aggressively. But the cost of getting from vague idea to usable prototype is now low enough that many more ideas make it through.

What actually changed for me

The biggest shift is how quickly I can get real feedback on an idea. Instead of investing hours just to see if something is worth building, I can reach a working prototype fast and judge its value right away. This means I spend less time on setup and boilerplate, and more on deciding what’s actually useful, trimming scope, and testing if the result feels right.

It’s still engineering work, just more focused on product judgment than manual construction. And because the cost of trying is so low, I’m more willing to treat ideas as experiments. If something’s useful, I keep refining it. If not, I’ve only lost a couple of hours supervising the AI, not a whole weekend of coding (or worse).

One recent example

TapLog is a simple Android app for logging recurring events with almost no friction. You create custom event types and place them on the main screen as large buttons. Tap once, and the app records the event with a timestamp. Long-press, and you can add a note. Later, you can review everything in a logbook, edit entries, export the data, or back it up locally.

It solves a very ordinary problem: I wanted to track missed bus rides during my commute. That’s exactly the kind of problem I mean. Real enough to be annoying, useful enough that data would help, but not obviously important enough to justify building a custom mobile app the old way.

With AI in the loop, it became easy to just make the thing.

What matters here isn’t that TapLog is technically impressive. It’s that it crossed the threshold from “I wish I had a tool for this” to “I have a tool for this” fast enough that the idea survived.

This app was built with Claude Code (Opus 4.6 1M context in plan mode), and that’s exactly why it exists. Without that workflow, I probably wouldn’t have given it the time.

Why this matters

This shift changes more than just developer velocity.

It changes what gets built.

When the cost of trying an idea drops, more niche, personal, and practical software gets made. More small tools exist because someone can justify building them now. That seems good to me. A lot of useful software doesn’t need to become a startup or a platform. Sometimes it just needs to solve one problem well enough to be worth keeping around.

And this matters beyond professional developers. I have the advantage of knowing how to evaluate tradeoffs, inspect code, and recognize when something is wrong. That still helps a lot. But the broader point stands: it’s much easier now for people to build software for problems they care about, even if they aren’t strong coders.

They still need judgment. They still need persistence. They still need to test what they build. But the barrier between having an idea and having a first working version is lower than it used to be. The hard part shifts away from typing every line yourself and toward knowing what to ask for, what to keep, and what to throw away.

Of course, there are tradeoffs. Lowering the bar means more experiments, but also more half-baked or disposable tools. Not every AI-generated app will be good, secure, or maintainable. And it’s easy to get caught up in building for the sake of building. But on balance, I think the benefits outweigh the risks, especially for personal projects.

Conclusion

AI coding tools are changing not just how fast I build, but what I build. They make it easier to turn small, personal ideas into real software. That’s a big deal for anyone who’s ever had a useful idea that wasn’t quite worth the effort of building before. Now, more of those ideas can see the light of day, and that’s exciting to me.

Stop wasting hours on Claude Code Pro's session cooldown

Sleeyax — Tue, 27 Jan 2026 21:47:14 +0000

If you're a Claude Code Pro subscriber, you know the pain: you burn through your session at 3pm, and then you're locked out until 8pm. That's a 5-hour cooldown with zero usage. Half your workday, gone.

I built a Telegram bot to fix this.

The problem

Claude Code Pro gives you a 5-hour session window. Once it expires, you wait 5 hours before you can start a new one. There's no way to queue up your next session in advance, so you either waste prime working hours waiting, or you carefully plan your usage around the clock.

Neither option is great.

My solution: automated warmups

Claude Code Session Bot is a self-hosted Telegram bot that starts Claude Code sessions on a schedule. The idea is simple: start the session while you sleep, work out or are away from your keyboard so it's partially used up but still active when you need it.

Example usage scenario: schedule /schedule tomorrow 9am before bed. The bot calculates that it needs to warm up at 6am. By the time 9am rolls around, you still have 2 hours of usage left. That's enough for a productive morning. By 11am the session expires, the cooldown starts, and after lunch you have a fresh session ready to go.

How it works

The bot runs on a VPS (or any always-on machine) with the Claude CLI installed and authenticated. When a scheduled warmup fires, it runs:

claude -p "ready" --output-format json

This sends a minimal prompt to Claude, which starts the 5-hour session timer. The bot records the session in a local SQLite database and tracks time remaining.

Commands

Command	What it does
`/warmup`	Start a session immediately
`/session`	Check active session status (time left, expiry)
`/schedule <datetime> [hours]`	Schedule a warmup so you have `[hours]` remaining at `<datetime>`
`/schedules`	List pending scheduled warmups
`/cancel <id>`	Cancel a scheduled warmup
`/history`	View recent session history

See the GitHub repo for full instructions.

Scheduling examples

/schedule tomorrow 9am        # 2h remaining at 9am (warmup fires at 6am)
/schedule monday 14:00 3      # 3h remaining at 14:00 (warmup fires at 12:00)
/schedule jan 30 8:00 4h      # 4h remaining at 8:00 (warmup fires at 7:00)

The math behind this is simple: warmup_time = target_time - (5h - desired_hours_remaining).

Date parsing is handled by chrono-node, so natural language like "tomorrow 9am" or "next monday 14:00" just works.

Architecture

The stack is intentionally minimal:

TypeScript with strict mode
SQLite (via better-sqlite3, WAL mode) for persistence
node-telegram-bot-api for the Telegram interface
In-memory setTimeout timers restored from DB on restart

No external services, no Redis, no message queues. Schedules survive restarts because they're persisted to SQLite and restored when the bot boots.

Limitations

The bot only tracks sessions it starts. There's no Anthropic API to query your current session status, and reverse-engineering internal endpoints risks account bans. So if you start a session manually from your dev machine, the bot won't know about it.

For best results, use the bot as your sole session starter from a dedicated VPS.

Final thoughts

This is a simple tool for a specific annoyance. If you're a Claude Code Pro user who's tired of session cooldowns eating into your productive hours, give it a try.

The project is open source (MIT license) - contributions and feedback welcome.

Write Dynamic GitLab pipelines in TypeScript

Sleeyax — Fri, 23 Jan 2026 21:06:16 +0000

As CI/CD pipelines evolve, they tend to grow in size, complexity, and inevitably... frustration. If you’ve ever maintained a large .gitlab-ci.yml file, you’ve probably felt the pain: copy-paste everywhere, no type safety, and mistakes that only surface when a runner fails at runtime.

This article introduces an alternative approach: defining GitLab pipelines in TypeScript, while still producing a perfectly valid .gitlab-ci.yml file that GitLab can run as-is.

Why TypeScript for GitLab pipelines?

GitLab CI configuration is written in YAML. YAML is fine for small pipelines, but once pipelines become complex, YAML starts to feel limiting:

No type checking
No refactoring support
No real abstraction or reuse
Errors show up late, during pipeline execution

Meanwhile, modern CI/CD platforms like PandaCI already allow pipelines to be defined in a real programming language out of the box.

Unfortunately, GitLab doesn’t support this natively.

I explored existing solutions, but none quite hit the mark:

node-gitlab-ci - no longer actively maintained
gitlab-dynamic-pipelines - a manually coded wrapper rather than a schema-accurate representation

What I wanted was something:

Simple and lightweight
Easy to update when GitLab’s schema changes
Mapped 1:1 to the official GitLab CI schema

So I built a small library to do exactly that: gitlab-ci-ts.

The core logic is only ~30 lines of code. The rest is auto-generated TypeScript types from GitLab’s schema.

If you're wondering why I don't just use includes, extends, anchors/references and gitlab-local-ci instead, see this comment.

The workflow

Instead of writing YAML by hand:

Define your pipeline entirely in TypeScript
Compile it to a .gitlab-ci.yml file
Commit both the TypeScript source and the generated YAML

GitLab still only sees YAML, but you get the benefits of TypeScript.

// gitlab-ci.ts
import { Cache, GitLabCI, transformToFile } from "@sleeyax/gitlab-ci-ts";

// Reusable cache.
const nodeCache: Cache = {
  key: { files: ["package-lock.json"] },
  paths: [".npm/"],
};

// General-purpose pipeline.
export const pipeline: GitLabCI = {
  default: {
    image: "node:20",
    cache: [nodeCache],
  },

  variables: {
    GIT_DEPTH: 0,
  },

  stages: ["test", "build", "deploy"],

  jobs: {
    // Hidden job to share install steps.
    ".install": {
      stage: "test",
      before_script: ["npm ci --prefer-offline --no-audit --if-present"],
      interruptible: true,
      cache: [nodeCache],
    },

    // Individual jobs.
    lint: {
      extends: ".install",
      stage: "test",
      script: ["npm run lint --if-present"],
      rules: [{ if: "$CI" }],
    },

    test: {
      extends: ".install",
      stage: "test",
      script: ["npm test --if-present"],
    },

    build: {
      extends: ".install",
      stage: "build",
      script: ["npm run build --if-present"],
      cache: [nodeCache],
      artifacts: { paths: ["dist/"] },
    },

    docker_push: {
      image: "docker:28",
      services: ["docker:28-dind"],
      stage: "deploy",
      before_script: [
        'echo "$CI_REGISTRY_PASSWORD" | docker login $CI_REGISTRY -u $CI_REGISTRY_USER --password-stdin',
      ],
      script: [
        "docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA .",
        "docker push $CI_REGISTRY_IMAGE --all-tags",
      ],
      rules: [{ if: "$CI" }],
    },
  },
};

// Write ".gitlab-ci.yml" file.
await transformToFile(pipeline, ".gitlab-ci.yml");

Ready to play around with it yourself? 👇

pnpm add @sleeyax/gitlab-ci-ts

See the gitlab-ci-ts repository for more examples and documentation.

Pros of TypeScript-driven pipelines

Type safety. Configuration mistakes get caught at compile time, not during a failing pipeline run.
Reuse and abstraction. You can share constants, extract helpers, and centralize common job definitions without copy-pasting YAML blocks across files.
Developer experience. You get autocomplete, inline documentation (TSDoc), safe refactoring, and earlier detection of invalid or unused variables.

Structure it however you want

Because the pipeline is just code, you’re free to organize it in a way that actually makes sense.

apps/pipeline
├── package.json
├── src
│   ├── cache.ts
│   ├── gitlab-ci.ts
│   ├── jobs
│   │   ├── environment
│   │   │   ├── development.ts
│   │   │   ├── production.ts
│   │   │   └── staging.ts
│   │   └── stages
│   │       ├── build
│   │       ├── deploy
│   │       ├── test
│   ├── main.ts
└── tsconfig.json

Future possibilities

Once your pipeline is defined as code, new doors open:

Unit tests for pipeline configuration
Easier large-scale refactors
Programmatic validation of rules, variables, and stages

Trade-offs and limitations

Obviously, this approach isn’t without downsides:

Extra abstraction layer. If GitLab introduces a feature that isn’t represented in the generated types yet, you may need to update the library.
Extra build step. You must compile the TypeScript to .gitlab-ci.yml before committing.

Final thoughts

Defining GitLab pipelines in TypeScript brings modern software engineering practices to CI/CD:

Type safety
Reusability
Testability
Maintainability

GitLab still runs YAML, but you don’t have to write it anymore.

Flexispot E7 Flow: A detailed review and installation tips

Sleeyax — Sat, 17 Jan 2026 20:10:20 +0000

This is my detailed review of the E7 Flow standing desk from Flexispot, including my experience with the ordering process, shipment, installation, and daily use. I'll also provide some tips and insights to help others who are considering this desk.

If you're looking for a TL;DR, see the conclusion at the bottom.

Desk specifications

Model: Flexispot E7 Flow
Size: 160 × 80 cm
Color: Volcano Grey
Accessories: No Extras
Site: flexispot.nl
Order date: 2025-11-28
Assembly date: 2025-12-06

Introduction

My previous desk was a simple rectangular, solid wood block-style desk with a 3-level drawer on the left and sitting area on the right. It was only 130 × 75 cm in size. I've been using that desk all my life as a student and later as a remote worker. It was boring, but extremely stable.

At work, I tried a standing desk for the first time and really liked it, so I decided to finally upgrade my home office with one as well. Finding a solid standing desk can be challenging, especially with so many options available and most of the well-known companies being based in the US.

After a couple of days of research, I found Flexispot to be a good option given its desk features, price/quality ratio, and positive reviews.

Initially, I wanted to go for the E7 Plus (four-legged standing desk) as I was afraid to experience the infamous wobble. But after reading further into it and considering my simple setup (desktop PC, monitor and dual speakers, no heavy equipment), I convinced myself it was overkill for my use case and placed my bet on a two-legged desk instead. The E7 Flow was just released around that time, so I decided to order it.

Ordering process

Black Friday was only a few months away, so I decided to wait for the sale. Flexispot had an "enter your email here and get a discount code" pop-up on their website for the E7 Flow, so I signed up. On the day, I noticed they had another discount going, and my code only saved me about 20 bucks more compared to that one - but hey, every bit counts.

The ordering process itself was smooth and I got a confirmation email right away.

Shipment

The package shipped in 3 separate packages, as mentioned on the website. Delivery was fast and professional, handled by local carriers.

Some minor annoyances:

The tracking numbers were not provided on the dashboard; it just said "shipping". I had to check my email for the tracking numbers received from the shipping companies.
The packages arrived on different days, one of which was sent by a different shipping company, so I had to keep track of multiple shipments and make sure I was home on those days.
Two of the packages were processed on the same day and shipped by the same company, so it would've been nice if they were aware they belonged together so both could be delivered on the same day by the same courier.

I'm not sure how much control Flexispot has over these issues, if any, though. So no big deal.

The package

The packages arrived in good condition, with no visible damage. The boxes were sturdy and well-sealed. This became even more apparent when I opened them and found the contents wrapped in multiple layers of protective material, including foam and plastic wrappers. No scratches or dents were visible on any of the parts.

Installation process

In the instruction video, they promised it would take about 20 minutes to install... Yeah well.

It took me - a complete newbie at assembling furniture - about 10 hours for the desk assembly itself, and 20+ hours total including cable management and organizing my workspace. If you're a complete newbie like me, take your time and don't rush it. It can be a fun project if you approach it with the right mindset.

It probably would've been easier if the instructions were more detailed. More on that below.

The instructions

I'll be honest: the instructions are a nightmare, especially for beginners. They're very minimal and lack detail. Some steps are not explained well, and some of the parts were scattered around the different boxes (for example the instruction manual says a part can be found in box A but it was actually in box C). I had to watch the installation video + read the manual multiple times to put the complete puzzle together and understand what to do.

Below I'll go over each step of the installation process and share my experience, including any issues I encountered and how I resolved them.

Preparation before installation

Install on foam / carpet to prevent scratches: I used the cardboard from the desktop box, which worked out alright. I had a minor scratch in the middle after assembly, but that's entirely my fault as I wasn't careful enough when moving the desk around.
Screwdriver / drill: not needed; I only used the tools that came with the package.
Get a friend to help: I managed to do the assembly and desk flip alone (I'm not exactly strong), but I did ask for help to move the desk into its final position. If you must do it solo from start to finish then it should be possible with some furniture sliders and patience.

01 - Attach the side brackets to the beam

This step was already pretty difficult for me. In the instruction video and manual, they only mention which side of the beam should be up, but they don't explain how to rotate the beam into the correct orientation. If you skip through the video, it is briefly shown that the "blue part" of the beam is on the instructor's right side, but it's easy to miss. Basically, if you have a power plug on the left of your desk (as I do), it's best to have the blue part on the other side of the beam than what is shown, so the power cable is closest to the plug. It would've been nice if this was mentioned in the instructions.

You also have to pay close attention to the side brackets, as one side of the bracket is longer than the other. Remember the E7 Flow has C-shaped legs, not T-shaped. This is easy to miss if you go over the instructions too fast. Also would've been nice if there was some kind of warning about this in the manual.

Furthermore, the manual mentions to "fit the shock-absorbing washers". But I couldn't for the life of me find these in the box. The video didn't even mention it and someone on the subreddit (a mod, if I recall correctly) said that they are not necessary. So I decided to skip this step. As I briefly mentioned above, the rubbers turned out to be placed in a completely random box at the bottom, in a different location than what the manual said. So be sure to check all boxes for any small parts you think you're missing.

02 - Adjust the length of the frame

A crucial piece of information is missing for this step: how to correctly position the desktop. The manual only shows a square desktop, but the E7 Flow has an ergonomic edge, so there is a clear "front" and "back" to the desk. The video doesn't clarify this either. If you look closely, you'll see that the "back" of the desk has two white "dots" on the underside, which are not present on the front. Make sure to align the frame with the correct side facing forward.

This positioning step itself was pretty straightforward, but demanded patience. I needed a flashlight to properly "look under" the beam as I positioned it to see if the holes aligned.

03 - Affix the desktop

This step should've been easy but caused another major confusion. There are unused screw holes on the beam in the middle of the frame. The manual mentions that "you may have extra screws depending on how far the frame is extended", but it doesn't clarify. In the video, they don't even mention it and skip over it. Looking this up on the subreddit, some people said they skipped it and other people said they just drilled the holes themselves. Given this is supposed to be a "pre-drilled holes" desk, I decided to just leave the holes unused as well.

The manual also warns to "keep the centerline label centered when adjusting the frame". This is not mentioned in the video, and I didn't notice it until after I had already positioned the frame. Luckily I had some room to adjust it a bit further inwards to center the label. Why wasn't this mentioned in the previous step where you position the frame?

Furthermore, the screws closest to the center of the beam didn't actually screw in as there was no real hole to screw them into. The pointy screw was basically pressing against the metal beam. Looking this up on the subreddit, people said this is a normal thing and you're just supposed to tighten it this way, not screw it in. This was so strange to me and it's not mentioned anywhere in the manual or video. More on that later.

04 - Install the leg columns

This step was (finally) easy.

According to a comment on the subreddit, this is the point where you could test the motors if you want to see if they work. It would've been nice if this was mentioned in the manual or video as well. I imagine this could have saved some people a lot of trouble if they discovered a faulty motor before fully assembling the desk.

05 - Attach the feet

This step required some extra attention again because the feet part has a long and a short side, similar to the side brackets. It's difficult to see on the picture in the manual, but the video shows it briefly. Make sure to attach the feet with the long side facing outwards. You can check out pictures of the assembled desk online to figure this out if you're unsure.

06 - Fix the keypad

This step was easy as well. Just make sure you attach it on the side you prefer. Remember that we still have to turn the desk around later, so choose accordingly.

I assembled the desk in a small corner in my room. If you're in a similar spot like me, make sure you don't accidentally break the keypad either when turning the desk around or moving it to its final position.

07 - Connect the wires

Finally another easy step. Just make sure to connect the wires properly according to the labels. The power cable didn't "click" into place for me like the other cables, but I just pushed it in firmly and it has worked fine so far.

08 - Adjust the foot pads for balance

This is where the video diverges from the manual a bit. The video goes over the cable tray first. For consistency, I'll document my experience in the same order as the manual.

The foot pads adjustment was pretty straightforward. Just make sure to adjust them evenly on both sides to keep the desk level. I heard some people skipped over this step and had issues with wobbling later on, so don't skip it unless you have a good reason to.

09 - Pre-installation preparation for the cable tray

This step was the worst one of them all. It says to "check if there are any protruding screws on the beam, if so replace them with set screws". So in other words, remember those screws in step 3 that didn't actually screw in? Yeah, unscrew those again and use these other screws instead! What?! This is so incredibly counter-intuitive. Why wasn't this mentioned in step 3 where you actually put in the screws? This would've saved me so much confusion.

Also, I kind of messed up one of the screws because I tightened it too much and it got stuck. I can't unscrew it anymore, so now I have a "set screw" that I can't replace. I'm not completely sure it affects the desk's stability or function, but so far it seems alright. But still, what a pain.

10 - Adjust the cable tray assembly

This step was easy. The tray itself felt a bit more flimsy than I expected, but it does its job.

11 - Attach the cable tray

This step was also straightforward, though I wasn't sure how tight the screws should be. Too tight and it feels like the tray might crack, too loose and it wobbles a bit. I just tightened them until they felt secure enough (though there's a bit of wobble still).

12 - Cable management

The included velcro straps are a nice touch. They are sturdy and reusable, which is great for cable management. I used them to bundle my cables together and keep them organized under the desk. Personally I had plenty of strap left over after managing all my cables, but that depends on your setup of course.

13 - Install the cable management U-bracket

Another nice touch to help with cable management. The included bracket feels sturdy. Sometimes it shifts a bit when I open the cable tray, but it's easy to reposition it. It doesn't fall off or anything, so no big deal.

14 - Install the cable organizer post

The next set of parts to improve cable management even further. The cable clips are easy to attach and move around. It does its job to keep the cables organized. I used it to route my monitor, dual speakers and desktop cables, which helps keep them from tangling.

The only minor gripe I have with this system is that the clips can't interfere with the beam (as mentioned in the manual). Thus, there's less "real" space in the tray than it looks initially. Depending on the type of cable (thick head or flat head, thick or thin cable), you might not be able to fit everything in there. For my setup, after fiddling around with it for a couple of hours and attaching the power strip at the perfect angle, it was just enough room to fit everything.

Out of the box you get 5 clips, which was more than enough for me. I only ended up using 3 of them. Again, your usage will vary depending on your setup and cable types.

15 - Install the power distribution unit

You can tell that the included power strip is of high quality. It has just the right amount of outlets (6) for my (present and future) needs. I had to apply a lot of pressure to plug my cables in though, so I recommend plugging them in before installing the power strip into the cable tray if possible.

At first, I was worried that the sockets were not compatible with my Belgian plugs. I contacted Flexispot support and they offered to refund me the cost of the power strip if it turned out to be incompatible. Very professional of them to offer that. After learning a bit more about international plug standards, I realized it was indeed compatible. The power strip has a universal design that accepts various plug types, including the Netherlands Type C, modern Belgian/French Type E and German Type F plugs.

One small complaint about the instructions: it would have been helpful if they mentioned that you can remove and rotate the mounting brackets on the sides of the power strip. Apparently, this is common for "server rack" style power strips, but I only discovered it after doing some research. Knowing this earlier would have saved me a lot of time fitting the power strip into the cable tray, since rotating the brackets allows for a better fit. In the video, the mounting brackets were also oriented differently than on my unit, which made me worry at first that I had received a faulty product.

16 - Install the velcro strap

A nice addition I didn't expect. The tray already closes magnetically, so it's not absolutely necessary but offers an additional layer of security to keep it closed when not in use.

17 - Install the magnetic cable channel

Another nice touch to keep the power strip cable and desk cable organized. The magnetic channel is easy to attach and remove. At first I felt like I didn't need it because my cable management was already managed so well thanks to all the other features, but it's a nice finishing touch nonetheless.

18 - Attach the cable clip

Personally I skipped this step because my cables were already well managed without it. But if you have extra cables that need organizing, I can see this extra cable clip being useful. You can peel off the sticker and glue it wherever you need it.

My experience using the desk

Below I'll go over my experience using the desk after having it for a couple of weeks now. I don't like to do 'scores' so I'll just list the best and worst experiences using the desk so far.

Best experiences

Stable in standing position. Wobble isn't as bad as I feared. With my light setup, I can type and work without any issues. I did notice some slight wobble when pushing against the desk, but it's not a big deal for normal use.
Smooth and quiet height adjustment. The dual motors work well together to provide a stable lift. This is my first standing desk, so I don't have much to compare it to, but I'm very satisfied with the performance. It's exactly as advertised.
Cable management system. The included cable management features are a big plus for me. The cable tray, clips, and power strip help keep my workspace tidy and organized. I appreciate the thought put into these features.
The USB-C port on the keypad is a nice addition for charging (mobile) devices. It's conveniently located and I use it more than I would have expected.

Worst experiences

Unstable in sitting position. My monitor wobbles when my desk is lowered to sitting position and I type on the keyboard. This was the most unexpected issue for me. I thought issues like this would be more pronounced when standing, but it's actually worse when sitting. My current theory is that it's actually my monitor (Gigabyte M28U) stand that is causing the wobble. When I touch my monitor lightly by hand, it already wobbles quite a bit. So when I type on the keyboard, the vibrations from the keystrokes transfer through the table to the monitor stand and cause the screen to wobble. I'm considering getting a more stable monitor or monitor arm in the future to see if that helps. This is close to being a deal-breaker for me, and made me question whether I should return the desk. My old desk is extremely stable so I never experienced this before. For now, I manage using a DIY solution by placing foam pads (from the desk's packaging) under the left and right sides of the monitor to stabilize it a bit more.
I'm not a fan of the "ergonomic" edge. I've been sitting on a desk with straight edges my whole life, so this took some getting used to. At first it felt like my arms were constantly slipping off the edge. After a couple of weeks, I've adapted to it, but at this point in time I would still prefer straight edges. Another thing I didn't consider enough when I purchased this desk is the fact that it's impossible to "clip" things to the front of the desk. For example I have a racing wheel (for video games like Forza Horizon 4/5) that I can no longer use on this desk. I use my desk more for work than gaming, so it's not a big deal, but something to consider if you plan to use accessories that need to be clamped to the desk.
The tabletop collects a lot of dust. Or maybe my room has always been dusty and it's just more visible now due to the grey color of the tabletop. Either way, I find myself cleaning the desk more often than I expected. Probably not a deal-breaker, but something to keep in mind.

Conclusion

Overall, I'm satisfied with my Flexispot E7 Flow desk. It has its quirks and challenges, especially during assembly, but once set up, it provides a functional and enjoyable workspace. The standing feature is a great addition to my home office, and the cable management system helps keep things tidy.

For me, it's a great standing desk, but the sitting experience is subpar because of my monitor wobble issue described above. If you're primarily looking for a standing desk and don't mind the ergonomic edge, I would recommend it. However, if you plan to use it mainly for sitting or have the exact same monitor as I do, I would advise caution and consider testing it out first if possible.

I Built a Better World Time API

Sleeyax — Wed, 13 Aug 2025 19:56:34 +0000

Have you ever needed to get the current time or timezone for a specific timezone or IP address, only to find that the available APIs are unreliable, outdated, or closed source? I did - and I decided to build a better solution.

Why Build a New World Time API?

The original worldtimeapi.org is a great idea, but it’s had its share of downtime and data issues. Other commercial APIs are often closed source, limited in features, or don’t offer plain text responses. I wanted something that was:

Fast and reliable
Open development
Up-to-date
Easy to use
Compatible with the World Time API

Introducing: timeapi.world

This project is a drop-in replacement for worldtimeapi.org, built with TypeScript and Cloudflare Workers for speed and scalability. It’s source-available under the Business Source License (BSL) and will automatically become open source after the BSL change date. It's free to use (currently up to 20,000 requests a month, commercial plans are available if you need more).

Key features:

🚀 High performance (Cloudflare Workers)
🟢 Reliable (serverless, global edge network)
📅 Frequently updated (IANA timezone + MaxMind GeoIP with automated updates)
📝 JSON & plain text responses
🌍 Geo IP support
🔄 Backwards compatible with worldtimeapi.org
👐 Source-available (BSL) -> open source after BSL change date.
🧑‍💻 Swagger/OpenAPI docs

API Endpoints

The API follows the World Time API spec:

Timezone Endpoints

GET /api/timezone – List all available timezones (JSON)
GET /api/timezone.txt – List all available timezones (plain text)
GET /api/timezone/{area} – List timezones for a specific area
GET /api/timezone/{area}/{location} – Get current time for a location
GET /api/timezone/{area}/{location}/{region} – Get current time for a region

IP-based Endpoints

GET /api/ip – Get time based on client IP
GET /api/ip/{ipv4} – Get time for a specific IP

All endpoints support both JSON and plain text (just add .txt).

Example Responses

JSON:

{
  "utc_offset": "-04:00",
  "timezone": "America/New_York",
  "day_of_week": 6,
  "day_of_year": 214,
  "datetime": "2025-08-02T13:02:11.703-04:00",
  "utc_datetime": "2025-08-02T17:02:11.703+00:00",
  "unixtime": 1754154131,
  "raw_offset": -18000,
  "week_number": 31,
  "dst": true,
  "abbreviation": "EDT",
  "dst_offset": 3600,
  "dst_from": "2025-03-09T07:00:00+00:00",
  "dst_until": "2025-11-02T06:00:00+00:00",
  "client_ip": "127.0.0.1"
}

Plain Text:

utc_offset: -04:00
timezone: America/New_York
day_of_week: 6
day_of_year: 214
datetime: 2025-08-02T13:02:51.390-04:00
utc_datetime: 2025-08-02T17:02:51.390+00:00
unixtime: 1754154171
raw_offset: -18000
week_number: 31
dst: true
abbreviation: EDT
dst_offset: 3600
dst_from: 2025-03-09T07:00:00+00:00
dst_until: 2025-11-02T06:00:00+00:00
client_ip: 127.0.0.1

Data Sources

Timezone data: IANA timezone database
Geo IP data: MaxMind GeoLite2

Both are industry standards and updated regularly using automation scripts.

How It Works

The API is built with:

TypeScript for type safety
Hono web framework for performance
Cloudflare Workers for global edge deployment
Cloudflare D1 for database storage

All endpoints handle both JSON and plain text, with proper error handling and CORS support.

Get Started

Check it out at https://timeapi.world/

Let’s make time APIs better for everyone.

Thanks for reading! If you enjoyed reading my content, follow me on X to stay in the loop ❤️.

Why I stopped using NixOS and went back to Arch Linux

Sleeyax — Fri, 07 Mar 2025 10:36:00 +0000

This post is a bit of a rant. Read at your own discretion.

About a year ago I switched from Manjaro linux to NixOS as a daily driver on my laptop. I run Arch linux on my desktop PC.

My setup in a nutshell:

NixOS installed on 2024-05-17 (stat / | grep "Birth")
Using nixos-unstable branch + flakes + home-manager + cachix
My nixos-config (public GitHub repo)

I fell in love with the idea of NixOS: as input you (basically) define your whole system configuration in a special config file syntax (Nix) and as output it gives you a reproducable build of your whole operating system and keeps track of changes so you can always revert back to an older generation if necessary. While this is nice on paper, it didn't end up working out for me.

After using NixOS for almost 1 year I decided to switch back to Arch linux on my lapop. Here's why:

NixOS breaks. All. the. time.

Ironically I broke Arch only once in 5 years whereas NixOS already breaks before updating. Something always requires a change in my Nix config before the nixos-rebuild command finally succeeds. It's a good thing this check is in place, but the constant rebuild > fix > rebuild > fix > rebuild > ... pattern becomes quite annoying after a while.

When the new configuration finally builds, more ofen than not some component randomly stops working after reboot. If it isn't broken copy paste between electron apps it is audio or bluetooth that randomly stopped working. I'm left alone to fix it with 0 clue as to why it broke.

Error messages are cryptic

This is related to my point above but it deserves its own section.

Look at this error:

$ sudo nixos-rebuild test --flake .#laptop
warning: Git tree '/home/sleeyax/Programming/nix/nixos-config' is dirty
building the system configuration...
warning: Git tree '/home/sleeyax/Programming/nix/nixos-config' is dirty
error:
       … while calling the 'head' builtin
         at /nix/store/xq5rfjj1z2r8yx338arajg5vwsxh1fri-source/lib/attrsets.nix:1574:11:
         1573|         || pred here (elemAt values 1) (head values) then
         1574|           head values
             |           ^
         1575|         else

       … while evaluating the attribute 'value'
         at /nix/store/xq5rfjj1z2r8yx338arajg5vwsxh1fri-source/lib/modules.nix:927:9:
          926|     in warnDeprecation opt //
          927|       { value = addErrorContext "while evaluating the option `${showOption loc}':" value;
             |         ^
          928|         inherit (res.defsFinal') highestPrio;

       … while evaluating the option `system.build.toplevel':

       … while evaluating definitions from `/nix/store/xq5rfjj1z2r8yx338arajg5vwsxh1fri-source/nixos/modules/system/activation/top-level.nix':

       … while evaluating the option `warnings':

       … while evaluating definitions from `/nix/store/xq5rfjj1z2r8yx338arajg5vwsxh1fri-source/nixos/modules/system/boot/systemd.nix':

       … while evaluating the option `systemd.services.home-manager-sleeyax.serviceConfig':

       … while evaluating definitions from `/nix/store/7dv77a007yd3z9w5gkvvn919nnrg2hf2-source/nixos':

       … while evaluating the option `home-manager.users.sleeyax.home.file."/home/sleeyax/.config/fontconfig/conf.d/10-hm-fonts.conf".source':

       … while evaluating definitions from `/nix/store/7dv77a007yd3z9w5gkvvn919nnrg2hf2-source/modules/files.nix':

       … while evaluating the option `home-manager.users.sleeyax.home.file."/home/sleeyax/.config/fontconfig/conf.d/10-hm-fonts.conf".text':

       … while evaluating definitions from `/nix/store/7dv77a007yd3z9w5gkvvn919nnrg2hf2-source/modules/misc/xdg.nix':

       … while evaluating the option `home-manager.users.sleeyax.xdg.configFile."fontconfig/conf.d/10-hm-fonts.conf".text':

       … while evaluating definitions from `/nix/store/7dv77a007yd3z9w5gkvvn919nnrg2hf2-source/modules/misc/fontconfig.nix':

       … while evaluating the option `home-manager.users.sleeyax.home.packages':

       … while evaluating definitions from `/nix/store/9cmg9v44pmw1fdz0bzn357djc8g2fn1g-source/modules/home':

       (stack trace truncated; use '--show-trace' to show the full, detailed trace)

       error: logseq has been removed, due to lack of maintenance and blocking the Electron 27 removal.

Do you spot the issue? Right! After spitting out a bunch of unreadable nonsense it says at the very bottom that the logseq package has been removed.

First of all, why bother with the verbosity if it's just a bunch of unreadable nonsense no one except package maintainers or core Nix devs can make sense of? Second - a bit off topic but... - removing a package I use daily without even suggesting an alternative or workaround. Seriously?

Huge update sizes

NixOS handles dependencies very differently compared to Arch Linux, leading to much larger update sizes. Instead of replacing packages in place, NixOS installs new versions alongside old ones, keeping multiple system generations.

For example, updating glibc in Arch Linux simply replaces the old version. In NixOS, every package depending on glibc is rebuilt or redownloaded, massively increasing disk usage. While this ensures rollback safety, it also means your system can quickly bloat up (unless you run nix-collect-garbage periodically).

# An example for the 'glibc-locales' package:
$ ls /nix/store | grep glibc-locales
0j3cpwmwab04jmvyzcqh538jzrnm60hn-glibc-locales-2.40-36.drv
0k4azawc10ygacxyqjz36cqghxsicqpr-glibc-locales-2.40-66.drv
2i4wm7zsm2nkn7sn2aj7ng4x1k3p71gz-glibc-locales-2.39-52.drv
2sk3c2n6p3aavhd7659ll2w63mv0i3aw-glibc-locales-2.40-66.drv
33alnvvkrp1s13vg5frn1zca34xbz424-glibc-locales-2.39-52.drv
51ssq420b3wqvcxmgmcw00hk8zkh6gvw-glibc-locales-2.39-52.drv
# ...

By contrast, Arch Linux updates are simpler to reason about. Old files are removed automatically and shared libraries don’t cause redundant downloads. If you care about minimizing disk usage, or your internet/network is capped, NixOS can be a nightmare.

Compilation takes forever (and binary caches are unreliable)

NixOS builds packages in an isolated environment, which often means compiling everything from source - even for minor updates. While binary caches like cachix theoretically speed up installations, they frequently miss packages due to system differences, forcing unnecessary compilation.

For example: if a dependency isn't cached exactly as required, NixOS will still rebuild it locally even if it's a common package. This can take hours, especially on slower hardware. On my machine regular maintenance updates without (or with bad caching) easily take 4-5+ hours to complete.

Meanwhile, Arch Linux simply downloads prebuilt binaries with pacman or an AUR helper, making updates take a couple of minutes instead.

If you hate waiting for your system to rebuild itself constantly, NixOS will drive you insane. If you love to recompile everything from scratch why aren't you using gentoo instead?

Poor documentation

Ironically, I tend to find better answers on the Arch Wiki than on the NixOS Wiki itself. The NixOS documentation is often vague, outdated, or overly abstract, assuming deep familiarity with Nix's unique concepts.

Practical examples are scarce and official guides frequently leave out crucial details forcing users to dig through forum posts or even GitHub issues to figure out basic tasks.

For a system as complex as NixOS, good documentation is essential. Unfortunately, it just isn't there.

Conclusion

I wish NixOS a bright future ahead to address all of its shortcomings. But until then it's no longer my favorite distro and I wouldn't recommend daily driving it as your desktop linux distro unless you have a very specific use case.

Alternatives already exist for its 'killer features':

Feature	Alternative
Generations	BTRFS snapshot volumes
Declarative package management	aconfmgr
Declarative configuration management	Dotfiles synced in a git repo
Nix flakes for development	Docker (or podman etc.)
`nix-shell`	nix package manager on Arch (or another supported distro)

Also keep an eye on system-manager (manage system config using nix on any distro) - which is still in early development at the time of writing.

Dynamic string validation using go's text/template package

Sleeyax — Mon, 23 Dec 2024 22:06:08 +0000

Imagine you could validate the following string:

id: "d416e1b0-97b2-4a49-8ad5-2e6b2b46eae0"
static-string: "abc"
invalid-string: def
random-number: 150

Using go template syntax like this:

id: "{{isUUID}}"
static-string: "abc"
invalid-string: def
random-number: {{inRange 100 200}}

Well, that would be cool wouldn't it? Unfortunately this isn't supported by go's text/template package.

I've built a library which uses a subset of the template syntax to cover this specific use-case: github.com/sleeyax/templatex-go. Check it out for a more detailed example!

Hi 👋 thanks for reading! If you enjoyed reading my content, consider following me on Twitter to stay in the loop ❤️.

Turn any website into a type-safe API using AI (part 2)

Sleeyax — Sat, 16 Nov 2024 17:24:44 +0000

In part 1 I went over a basic solution on how to scrape data from any website into any desired format using AI. This part covers the next steps to improve performance and reduce costs.

This part is a bit shorter because I no longer have the time to delve too deep into these subjects, but if you're on a similar path and enjoyed reading part 1 then I hope these 'field notes' can serve as inspiration in your own research. If you got any more tips, or questions, feel free to leave a comment below.

Reduce costs & optimize performance

As mentioned in part 1, using OpenAI's models as-is can get quite expensive. This section covers the different strategies I've found to reduce costs.

Convert HTML to LLM-friendly text

HTML elements contain quite a lot of 'bloat' by design. All of that extra markup isn't all that useful to our model, but it does count towards our token spend limit. In order to avoid that, we could try and convert that HTML into a different format (like markdown) that is not only smaller but also easier to parse by the model.

Jina Reader

Using the Jina Reader API or by self-hosting its models, we can convert the HTML to Markdown:

As you can see, there's way less bloat in there compared to the raw HTML output. Pass this to the model and it should still work while costing you less tokens.

Firecrawl

Another solution is Firecrawl, an open source project to crawl, scrape and clean your data. They offer a hosted paid version but its core features are free and open source on GitHub. So you could set up your own instance for free.

Crawl4ai

If speed is your uppermost priority or you simply don't like firecrawl, the completely free and open source crawl4ai project might be a better option to look into.

Different models

OpenAI isn't the only player in the AI game. There are more affordable options available. To name a few:

There's plenty of options to choose from, but not all of them work well with structured/JSON output mode (yet). Let me know in the comments which provider ended up working well for you!

Other challenges

The real challenges that comes with a project like this are the following:

Scraping websites that are protected by a WAF (Web Application Firewall), dealing with "anti bot" challenges, captchas etc.
Avoiding bans by rotation proxies
Keeping AI/LLM costs low
Handling bad data or AI hallucinations
Scaling the infrastructure

So please think twice before your start yet another business around this (very saturated) idea ;)

Hi 👋 thanks for reading! If you enjoyed reading my content, consider following me on Twitter to stay in the loop ❤️.

How to get rid of fake followers on X (Twitter)

Sleeyax — Sun, 20 Oct 2024 12:36:16 +0000

TL;DR: I built a free, fully configurable and open source browser extension called X Bot Sweeper to remove fake followers and bots on X for good. Jump straight to the solution or read ahead for more information.

What we'll cover

Introduction
The negative impact on your X account
Why are bots following me on X?
Spotting a fake account
Solutions
- Manual removal
- Browser extension
  - Configuration options
Conclusion

Introduction

Almost every day I get notified of obviously fake followers (bots) who started following me on X (formerly Twitter):

Some of these bots also send DMs (Direct Messages) asking seemingly benign questions. It's super obvious these messages are AI-generated though:

In another DM I even tried a couple of basic prompt injection techniques to get the LLM to drop the act, but alas:

The negative impact on your X account

You might be thinking "Why even bother? Free followers don't hurt right?". Well, in reality the exact opposite is observed to be true.

Even though we don’t have full insight into the X engagement algorithm, it's safe to assume that bot followers negatively impact your account’s reach and engagement. Here’s why it’s a good idea to take precautions:

Algorithm Sensitivity: X’s algorithm may evaluate the quality of your followers when deciding how widely to share your content. Bot followers could lower your visibility.
Engagement Levels: Bots don’t usually interact with your posts, leading to lower engagement rates. This could cause the algorithm to see your account as less valuable.
Account Reputation: An abundance of bot followers can make your account appear less credible to both the platform and real users.
Staying Ahead: As social media algorithms continue to change, removing bots now could help protect your account from potential future consequences.

In short, consider removing bots to reset the authenticity of your X account.

Why are bots following me on X?

So what's the point? Below are the top 5 reasons why bots are being employed like this.

1. Boosting follower counts

Most of these bots follow a large number of random users, hoping for a follow-back. This strategy helps them increase their follower count quickly. They might not care who you are specifically; you're just a potential addition to their follower base.

2. Promoting scams

Bots are often used to promote certain products, services, or websites. By following you, they might be aiming to get your attention, hoping you’ll check out their profile and see what they’re promoting. This could range from harmless products to sketchy links, scams and phishing campaigns.

3. Algorithm manipulation

Some bots exist to manipulate trending topics or amplify certain posts by engaging with a particular set of users. By following you, they might be trying to get more people to see and engage with specific content, thereby influencing the platform's algorithm.

4. SMM panels

Bots want to look like genuine users. By following random people, they attempt to mimic natural human behavior. Having followers can make them appear less like a bot account, especially if they plan to interact later.

Genuine-looking bot accounts are often employed by illicit 'SMM panels' to boost traffic on particular social media posts. An SMM (Social Media Marketing) panel is essentially an online platform that offers a wide range of social media services. These services can include purchasing likes, followers, comments, shares, and more on popular social media platforms such as but not limited to X.

5. Catfishing

An accounts with an attractive profile picture might send you a DM (Direct Message) to strike up a conversation, pretending to be someone they're not. Their goal is to build a relationship and gain your trust.

Once they’ve established a connection, the scammer behind the account uses emotional manipulation to trick you into sending money, gifts, or personal information. They may fabricate stories about needing financial help, having an emergency, or planning to visit you.

Sometimes, they might also send links in DMs that lead to phishing sites, malware downloads, or scam websites. Clicking on these can compromise your personal information or device security.

Spotting a fake account

It's relatively easy to spot a fake follower. They usually match at least half of the following criteria:

Attractive (usually female) profile picture. Likely AI generated.
Very high 'following' count
Very low 'followers' count
Few posts. Or 1 single post containing nonsense.
Many randomly reposted posts to appear active.
Account has been created very recently

The solution

Manual removal

You can manually remove these bots by visiting their profile pages and blocking each of them individually. This can be very time-consuming though, especially if you have a large number of followers.

Browser extension

I created a free, fully configurable and open source browser extension to help you get rid of bots semi-automatically.

Get started in 5 simple steps:

Install the X Bot Sweeper extension from my GitHub repository: sleeyax/x-bot-sweeper. Links to the Chrome web store and any other browsers or platforms we support now or will in the future are provided there.
After installing the extension, navigate to x.com/home at least once. This step is crucial for the extension to initialize itself for the first time. You will gracefully receive an error message if you forget this step.
Open the extension and click 'scan' to analyze your followers for unwanted accounts.
Confirm which accounts you want to get rid of by selecting them on the left and then click the 'block bot(s)' button at the top.
Go grab a drink while the extension blocks all of the accounts you selected. This action can take a while depending on the amount of followers your selected and the configured timeout in the extension settings.

Done! From now on every time you are notified of new fake followers you can repeat the process starting from step 3. I recommend performing a scan every week or month, depending on the severity of your bot problem.

Extension Settings

You can fully customize the extension to your needs. This is recommended for advanced users only. When in doubt, leave it at the default settings.

Right click the extension icon.

Or, if you didn't pin the extension yet, click this menu icon instead:

Then, select 'Options':

This should bring you to the extension configuration page:

The fields should be self-explanatory, but you can always hover over the question mark icon if you need more information about a particular field.

Conclusion

Removing fake followers from your X account is an essential step to maintain your account’s credibility, engagement, and long-term success. While this might seem like a daunting task at first, it’s worth the effort to ensure your audience is authentic and engaged, which can positively impact how the platform’s algorithm views your content. Taking the time now to clear out fake followers using the X Bot Sweeper browser extension will help protect your account’s reach and reputation as social media platforms continue to evolve.

If you have any questions, feel free to leave a comment below. Please report any bugs you encounter here. Contributions to improve the extension are always welcome!

If you enjoyed reading my content, and you are human, consider following me @sleeyax on X ❤️.

Turn any website into a type-safe API using AI (part 1)

Sleeyax — Wed, 09 Oct 2024 01:22:10 +0000

Not too long ago I saw this post on X/Twitter: // Detect dark theme var iframe = document.getElementById('tweet-1833539593054130336-993'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1833539593054130336&theme=dark" }

This idea intrigued me for a few days: turning any website into an API using AI? It sounded almost too good to be true. However, after experimenting with it, I can confidently say it’s not only possible but also much easier to achieve than you might expect.

In this post I'll uncover the secrets 😏.

How it works

In a nutshell the flow to go from an arbitrary webpage to a structured JSON object is as follows:

Scrape the webpage
Convert the HTML content into LLM-friendly text
Feed the converted data to an LLM
Instruct the LLM to extract the content into the provided JSON schema

Heads up: The code snippets below will be provided in TypeScript. If you prefer python - or any other programming language for that matter - I think you'll be able to follow along relatively easy though.

Naive approach

Let's start with the most basic approach to this problem by utilizing OpenAI's GPT 4o model. OpenAI recently launched structured JSON outputs, which makes the JSON processing part in the final step much easier.

Let's start by defining a similar function interface to the one we saw in the tweet:

export type ExpandOptions = {
  source: string;
  schema: z.ZodType;
  schemaName?: string;
};

export async function expand({
  source,
  schema,
  schemaName,
}: ExpandOptions) {
  // ...
}

Next, define your data schema with zod. We'll define a schema that resembles the example in the tweet:

const companySchema = z.object({
  name: z.string(),
  batch : z.string(),
  url: z.string(),
  industry: z.string(),
});

const companiesSchema = z.object({
  companies: z.array(company),
});

Now we can move on to implementing the exciting bits using the openai package:

export async function expand({ source, schema, schemaName }: ExpandOptions) {
  // Instantiate the OpenAI client
  const openai = new OpenAI({
    apiKey: process.env.OPENAI_API_KEY,
  });

  // Fetch the HTML content (in plaintext) of the target URL.
  const res = await fetch(source);
  const input = await res.text();

  // Send the input to the model and parse the output according to the schema.
  const completion = await openai.beta.chat.completions.parse({
    model: "gpt-4o-2024-08-06",
    temperature: 1,
    messages: [
      {
        role: "system",
        content: `You are an expert entity extractor that always maintains as much semantic
meaning as possible. You use inference or deduction whenever necessary to
supply missing or omitted data. Examine the provided HTML content and respond 
with a JSON object that matches the requested format.`,
      },
      { role: "user", content: input },
    ],
    response_format: zodResponseFormat(schema, schemaName ?? "result"), // Converts the Zod schema to a JSON schema.
  });

  // Extract the parsed output from the model's response.
  const output = completion.choices[0].message.parsed;

  if (output == null) {
    throw new Error(
      "Failed to parse the model's output according to the schema"
    );
  }

  return output;
}

Finally, call the expand function:

const companies = await expand({
  source: "https://www.ycombinator.com/companies",
  schemaName: "Companies",
  schema: companiesSchema,
});
console.log(companies);

Make sure you've set the required environment variable OPENAI_API_KEY to your OpenAI API key and run the example:

npx tsx ./src/example-openai.ts

You should get the following output:

{ companies: [] }

So why didn't it work? The problem with the page we're trying to scrape on https://www.ycombinator.com/companies is that it relies on dynamic content. Basically, the list is empty on initial page load and only gets filled once some javascript code has finished loading the data from their API. You can confirm this by inspecting the page HTML source (CTRL + U). You'll notice that none of the items from the list can be found directly in the HTML source:

Thus, we'll need to run this javascript in order to render the full companies list. A regular HTTP client like fetch won't be able to do that, so we'll add browser automation to the mix.

We'll create another function which loads the page in a real browser and then extracts the rendered HTML content as soon as the page finished loading. We can use puppeteer to accomplish this:

async function fetchHtml(source: string) {
  const browser = await puppeteer.launch();
  const [page] = await browser.pages();
  // Wait until the page is fully loaded.
  await page.goto(source, { waitUntil: 'networkidle0' });
  // Extract the HTML content.
  const data = await page.evaluate(() => {
    // Remove unnecessary elements from the page to reduce the size of the content. This is absolutely necessary to prevent OpenAI token limits.
    for (const selector of ['script', 'style', 'link[rel="stylesheet"]', 'noscript', 'head']) {
      document.querySelectorAll(selector).forEach(el => el.remove());
    }
    // Return the rendered HTML content.
    return document.querySelector('*')!.outerHTML;
  });
  await browser.close();
  return data;
}

Now, modify your expand function as follows:

// ...
const input = await fetchHtml(source);

Finally, run the code again:

$ npx tsx ./src/example-openai.ts

{
  companies: [
    {
      name: 'Airbnb',
      batch: 'W09',
      url: 'https://www.ycombinator.com/companies/airbnb',
      industry: 'Travel, Leisure and Tourism'
    },
    {
      name: 'Amplitude',
      batch: 'W12',
      url: 'https://www.ycombinator.com/companies/amplitude',
      industry: 'B2B'
    },
    {
      name: 'Coinbase',
      batch: 'S12',
      url: 'https://www.ycombinator.com/companies/coinbase',
      industry: 'Fintech'
    },
    # ...

🎉 Congratulations, it works!

Conclusion

There's an elephant in the room. As we're dealing with a lot of tokens here (useless HTML tags also count towards token consumption) this can get quite costly. A single round-trip already cost me about $0.14:

That's $14 every 100 requests! Now imagine scraping a complex site...

I'll address cost reduction strategies, performance optimization and other challenges in part 2 of this post.

Sources

The prompt used in the example was taken (and slightly modified) from:

https://github.com/cigs-tech/cigs (MIT license)

Hi 👋 thanks for reading! This was my first ever post on dev.to. It ended up too long so I decided to cut it in multiple parts. If you enjoyed reading my content, consider following me on Twitter to stay in the loop ❤️.