Forem: Asaf Lecht | אסף לכט

From Meeting Mayhem to Prompt Precision

Asaf Lecht | אסף לכט — Thu, 27 Nov 2025 00:00:00 +0000

Today was one of those days—a firehose of information from back-to-back meetings that left my head spinning. I felt like the only one in the room struggling to connect the million theoretical ideas being thrown around to a practical reality. Honestly, if I hadn’t recorded the calls, I’d have no idea how to even write a summary. It’s a reminder that sometimes the most important tool is the one that helps you process the chaos.

After untangling the meeting notes (with a lot of help from AI), I dove back into my video analysis project. The goal is to process a full hour of video without the model hallucinating, and I’m getting close.

Here’s a bit of the journey today:

Tackling Information Overload: Long, rambling meetings are a huge challenge for me. Recording them and using an AI to distill key points has become a non-negotiable part of my workflow. It helps me cut through the noise and focus on actionable tasks.
Slicing the Video Salami: My main strategy for analyzing long videos is to break them into 10-minute chunks and process each one separately. The real trick is stitching the results back together into a coherent whole without introducing errors or weird artifacts.
A Two-Prompt System: I’m using a main prompt for the overall task and a secondary, dynamic prompt for each video segment. Code injects relevant context into the secondary prompt for each chunk, which helps keep the model on track.
Prompt Structure is Everything: I noticed some small hallucinations still creeping in. It hit me that the structure of the prompt might be as important as the instructions themselves. Just throwing more instructions into a single block isn’t effective. I need to explore how different formats impact the output.

It’s a strange feeling to be building trust with a new manager while also feeling like you’re trying to build a plane in mid-air. But I love the process of taking a messy problem, breaking it down, and methodically testing solutions. The new era of development feels less about knowing how to write every line of code by heart and more about being a good architect and problem-solver. It’s a good fit for how my brain works.

Next: Systematically test different prompt structures on the same video to see what minimizes hallucinations the most.

Tags: AI, Prompt Engineering, Video Analysis, LLMs, Developer Life, Productivity

From Outlook Hacks to AI-Powered Forms: A Week of Juggling

Asaf Lecht | אסף לכט — Tue, 25 Nov 2025 00:00:00 +0000

It’s been a whirlwind of a week, jumping between projects. I finally wrapped up the 5S form automation, but there was no time to rest—a couple of new, interesting challenges immediately landed on my plate. It feels like I’m living and breathing in the Google ecosystem lately, with AI as my constant co-pilot for everything from coding to brainstorming architectural solutions.

It’s been a mix of satisfying wins and head-scratching problems. Here are a few highlights from the trenches:

Wrestling with legacy tech. Finished the 5S form automation, but a last-minute request to change a graph type sent me down a rabbit hole. The main culprit? Old Outlook, which uses Word’s ancient rendering engine. It was a pain, but I insisted on a solution that worked everywhere. It’s a good reminder: if you’re going to build something, build it right. The result is a solid, reusable script.
AI-generated UIs are a game-changer. A friend suggested I try building a new multi-language “improvement suggestion” form entirely with Google Apps Script. I was skeptical, but with some help from AI, I generated the whole thing—complex branching logic and all—in a fraction of the time it would’ve taken manually. It felt like a superpower.
Thinking in streams, not files. On my video analysis project, I hit a wall with handling large uploads. Instead of getting bogged down with splitting files using FFMPEG, I realized I could just use an API to point to specific timestamps. This lets me process massive videos in chunks without ever actually modifying the source file. A simple idea that solves a huge headache.
The “is it production-ready?” reality check. My new manager is a software engineer, and he’s pushing me to think more about scale and robustness. It’s a little intimidating, and the imposter syndrome is real. But he’s right. It’s a good push to level up my thinking from “make it work” to “make it last,” especially on a project I’ve led from scratch.

This period has been a mix of deep technical dives and high-level strategy. Leaning on AI is really accelerating things, but the real growth comes from these tough challenges—whether it’s a stubborn piece of legacy software or a manager pushing me to be better. It’s a lot to juggle, but I’m learning a ton and making connections with smart people that make it all worthwhile.

Next: Building out the automated dashboard for the new improvement-suggestion form.

Tags: Google Apps Script, AI, Automation, Imposter Syndrome, Video Processing, Legacy Code

Sometimes the Simplest Tool is the Right One

Asaf Lecht | אסף לכט — Thu, 13 Nov 2025 00:00:00 +0000

It’s been a whirlwind couple of days, jumping between a bunch of different tasks. I’ve been trying to standardize some internal processes, providing quick fixes for manual work, and pushing my main video analysis project forward. It’s a real mix of high-level strategy and getting stuck into the technical details.

Here’s a snapshot of what’s been on my plate:

The best solution isn’t always AI. I was asked to help with a process where an employee spends 3-10 hours manually comparing printed invoices against our inventory in Excel. My first thought was some complex OCR solution, but after a quick look, I realized the answer was much simpler. We just need to get the invoice as an Excel file from the supplier and use XLOOKUP. A five-minute fix that saves hours of work, no AI required.
Progress on the video analysis project. We had a good meeting with senior management and got the green light to move forward. We’ve purchased three GoPros to start documenting our assembly lines. The goal is to automatically calculate standard times for tasks, which is a huge need right now.
Hitting some technical roadblocks. Now for the hard part. I need to figure out the pipeline for the video project. How do I handle super long video files? Should the processing happen locally or in the cloud? Where do we store all this data? And I’m worried that if a browser tab crashes mid-analysis, the results will be lost. Lots to solve here.
Trying to add value with process flows. I’ve been using Claude to create standardized, visual process flows for our assembly steps. The feedback has been positive, but I’m still trying to figure out how to measure the real-world value this brings.

It’s a good reminder that this job isn’t always about building complex AI systems. Sometimes the biggest impact comes from identifying a simple, non-technical solution that saves people from tedious work. These small, practical wins feel just as important as cracking the big technical challenges.

Next: Start mapping out the video analysis pipeline, focusing on how to handle long files and where to store the data.

Tags: process automation, AI, Excel, video analysis, problem solving, lean manufacturing

Refactoring, Rabbit Holes, and a Reverse-Engineering Breakthrough

Asaf Lecht | אסף לכט — Thu, 30 Oct 2025 00:00:00 +0000

Today was one of those days that went in three directions at once. The main plan was to continue a major refactoring of our video routing project, but a couple of interesting side quests popped up and demanded attention. It was a classic juggling act between disciplined engineering, a tempting distraction, and a personal project that finally clicked.

I spent a good chunk of the day making sure our refactoring was solid. After migrating most of the code with AI assistance, I found it had missed a few old functions for exporting to Excel. Getting those back in was easy, but it tanked our radon code quality score. It took some focused work with black and mypy to clean things up and get back to an ‘A’ rating. If you’re going to refactor, you have to do it right.

Here’s a snapshot of the day’s ups and downs:

The Automation Rabbit Hole: An interesting request came in for an automation involving xlswings and Outlook. While it was a fun chance to play with a new library, I sank too much time into it before realizing Google Sheets was probably a better tool for the job. I pushed the code to Git and decided to move on—a good lesson in choosing the right tool before diving in.
A Surprise API Win: I got an early start and decided to tackle a personal project I’ve picked up and dropped several times: reverse-engineering a notebook service’s private API. The goal is to build a chat interface that uses it as a backend.
It Actually Worked! After a lot of trial and error, I finally got a coherent, Hebrew response from the service through my custom interface. Seeing it work was an incredible feeling.
The Next Hurdle: The connection isn’t persistent and relies on manually refreshing cookies. The next step is figuring out how to maintain a stable session, which will probably mean setting up a VPS.

It’s easy to feel like I was all over the place, but the thrill of the API project breakthrough made the whole day feel like a win. Moving between grinding on code quality, exploring a new idea, and achieving a personal goal is what makes this work so engaging.

Next: Finish the simple 5S automation I’ve been putting off—it’s quick, valuable, and needs to get done.

Tags: Python, Refactoring, API, Code Quality, Automation, Side Projects

An Unexpected Day of APIs and Data Scraping

Asaf Lecht | אסף לכט — Thu, 30 Oct 2025 00:00:00 +0000

I wasn’t planning on coding today, but a quick request turned my day off into a surprisingly productive session. It started with a simple problem—finding neighborhoods for thousands of addresses in Jerusalem—and ended with me diving deep into a web scraping challenge for a new RAG project. It was a perfect example of two very different kinds of development work.

Here’s a bit of what I ran into:

APIs beat agents for bulk data. The request was to get the neighborhood for ~4,000 addresses. My gut told me an AI agent would be incredibly slow and unreliable for that scale. A quick search with Claude confirmed my suspicion: the OpenStreetMap API was the right tool for the job.
AI is a killer co-pilot. I used Claude for the whole mini-project: finding the right API, parsing the ugly JSON response (it pointed out the suburb field was what I needed), and then writing the entire Python script in a Google Colab notebook. It ran with minimal debugging, which was a pleasant surprise.
Data quality is always the catch. The script worked great, but the output wasn’t 100% perfect because the input address list wasn’t clean. Still, for a quick-and-dirty solution, it was a solid win.
Scraping is the real grind. After that quick win, I started a new project: building a RAG system for a Rabbi’s website, which is packed with text. Getting access was easy, but extracting the content is proving to be the real beast.
Backend data structure can be a nightmare. My current headache is that on the site, questions and their answers are stored as separate files. I need to figure out how to reliably merge them. It’s a messy, foundational step that will determine the success of the whole project.

Today was a tale of two tasks. The first was a clean, satisfying win that went from problem to solution in no time, thanks to a clear API. The second is a reminder that most of the work in data projects is just getting your hands on clean, structured data. It’s a messy process, but I’m excited to see where it goes.

Next: Keep wrestling with this web scraping and figure out how to properly link all the questions and answers for the RAG dataset.

Tags: API, Python, Web Scraping, RAG, Claude, OpenStreetMap

The Spider Chart and the Slippery Slope of a “Quick” Project

Asaf Lecht | אסף לכט — Tue, 28 Oct 2025 00:00:00 +0000

A new request landed on my plate last week: automate the 5S audit process. Right now, it’s painfully manual. An employee walks to 10-12 different locations with a paper form, fills it out, then trudges back to a computer to type everything into Excel. After that, they have to manually calculate the results and email them to the right people. It’s a 15-30 minute time sink per person, which is especially ironic since this is for our Operational Excellence (OPEX) team.

Naturally, I thought, “Easy fix! I can automate that.” I jumped right in, figuring it would take an hour, tops. Famous last words. That one hour quickly spiraled into many, reminding me (again) that I need to slow down and scope things out properly.

Here’s where I’m at:

The Problem: The current 5S audit is a manual, paper-based process that wastes a significant amount of time on data entry and reporting.
The Quick Win: I successfully replaced the paper forms with a Google Form. Now, employees can complete the audits on their phones, and the data flows directly into a Google Sheet. That part is a definite success.
The Roadblock: The automation is stuck. My biggest headache is trying to reliably generate a “spider chart” (a radar chart) using Google Apps Script. It’s just not working consistently.
The Unfinished Business: Because of the chart issue, the final reports and emails still have to be sent out manually, which defeats half the purpose of the project.

Honestly, this little project has drained a lot more energy than I expected. I see the value in finishing it, and I hate leaving things incomplete, but it’s become a real time-vampire. It’s another classic example of how development projects, no matter how small they seem, always have a few surprises waiting for you down the road.

Next: Finish this automation… just maybe not this month.

Tags: automation, Google Apps Script, scope creep, process improvement, 5S, Google Forms

From Scoping Down to Building Up

Asaf Lecht | אסף לכט — Fri, 24 Oct 2025 00:00:00 +0000

The last couple of days have been a mix of professional pragmatism and a fun side-quest helping a friend. It’s a good reminder that sometimes the best move is to not build something, while other times, it’s about rolling up your sleeves to build from the ground up.

At work, a proactive new colleague in OpEx is improving our 5S process. We were about to build a system to automatically generate a complex progress graph from a massive Excel file. It felt like a lot of effort, so I pushed back with a simple question: does anyone actually need this? After talking to a few managers, the answer was a clear no. We saved ourselves a ton of development time by deciding to just copy-paste the graph quarterly. It’s a huge win for keeping things simple.

Here are a few highlights from the last couple of days:

Challenging requirements is key. We avoided building a complex, time-consuming feature by validating its necessity with the actual users first. A simple conversation saved us days of work.
Paying technical debt is a grind. I’m continuing to write tests for our video analysis project to enable safe refactoring. It’s slow, painstaking work that highlights the cost of starting a project without a solid testing foundation. A lesson learned the hard way.
Mentoring is incredibly rewarding. I was supposed to be on a sick day but ended up helping a friend set up his business domain, connect his professional email, and brainstorm his tech and business strategy. He offered to pay, but just helping him get started was payment enough.
Building from a clean slate feels great. After wrestling with the messy codebase at work, helping my friend build his website and story from scratch was a breath of fresh air. We got a nice site up, clarified his offerings, and talked about how he can showcase his skills to clients.

Reflection

It’s been a lesson in contrasts. At work, we made the right call to avoid a complex feature, but I’m simultaneously feeling the pain of not having a solid foundation on another project. Then, helping my friend was a powerful reminder of how satisfying it is to build things the right way from day one. It’s all part of the learning process.

Next: More refactoring and test writing for the video analysis project.

Tags: testing, refactoring, project management, mentorship, developer life

A Day of Consulting, Coding, and Scope Creep

Asaf Lecht | אסף לכט — Sun, 19 Oct 2025 00:00:00 +0000

Today was a wild ride, jumping between completely different worlds. One minute I was getting a reality check on a startup idea, the next I was architecting an LLM solution for a client, and I finished the day by finally fixing a buggy personal project. It’s days like these that really stretch your brain in the best ways.

I started the day with a call with a startup consultant. I wanted to get some feedback on a bigger idea I’ve been kicking around, and it was a great, free way to get an experienced perspective. Then, I had a surprise call where I was the one giving advice on AI. I wrapped up by diving back into my own code.

Here are a few takeaways from the day:

Startup Reality Check: Building a startup, especially a B2G (Business-to-Government) one, is no joke. The consultant immediately asked about the business model, market size, sales cycle, and competitor landscape. It’s a good reminder that an idea is just the first 0.1% of the work.
From Imposter to Consultant: I found myself advising a team on building a custom chatbot. They were stuffing huge amounts of text into a single prompt and getting bad results. It was a perfect use case for RAG (Retrieval-Augmented Generation) to pull accurate info from their documents. I also suggested fine-tuning a model to capture a specific person’s writing style. It’s wild to realize my deep dive into this stuff has made me knowledgeable enough to help others.
The Scraper Saga is Over: My synagogue YouTube scraper project has been running and freezing for ages. Today, I started fresh. With a little back-and-forth between GPT and Claude, I finally got it working! It’s now successfully pulling all the videos from the target playlists. Feels so good to get that unblocked.
…And Hello, Scope Creep: Of course, the moment the scraper worked, my brain immediately jumped to the next thing. Now I want to build a simple local UI to make the scraped videos searchable and add an option to download compressed versions. Every small project just wants to become a big one.

It’s funny how these different activities connect. The high-level startup talk grounds my technical work in business reality, while the hands-on coding keeps my skills sharp. It was also a good confidence boost to be able to provide real value with my LLM knowledge. The day was a reminder that progress isn’t always linear, but it’s happening on multiple fronts.

Next: Time to start building out that local UI for the video scraper.

Tags: llm, startup, python, rag, side-projects, learning-in-public

Wrestling with Broken Paths and a Looming POC

Asaf Lecht | אסף לכט — Fri, 17 Oct 2025 00:00:00 +0000

Well, today was one of those days. I had a clear plan to make progress on my video analysis and work-instruction projects, but things just kept breaking. It felt like every step forward came with a new, unexpected problem, and I spent most of my time putting out fires instead of building. A classic day of groundwork where you end the day feeling like you’ve barely moved.

Here’s a rundown of the struggles and takeaways:

Broken paths, again. In the work-instructions project, which uses an LLM to generate procedures, all the image and video paths broke on me. Again. I suspect it has something to do with a recent interaction with the ChatGPT API, but I’m not sure why. It’s frustrating because I thought I’d finally stabilized that part.
The surprise GPT-4 limit. I was trying to debug the issue and suddenly hit a 5-hour usage limit on GPT-4. I had no idea that was a thing, and it completely caught me off guard. Another lesson learned the hard way.
The pressure of a POC. We have a conference coming up and need a Proof of Concept for the video analysis tool. The goal is to show a simple station that can analyze a video of an assembly process, measure task times, and export a report. This deadline is forcing me to refactor the monolithic code, but I’m also starting to wonder if this refactoring effort is the best use of time right now.
Hardware gremlins. To top it all off, my computer wouldn’t start this morning—just a black screen with a cursor. I spent half an hour convinced my hard drive had died before it magically fixed itself. I’m still worried it’s a sign of a bigger problem to come.

It’s frustrating when you feel like you’re doing a lot of work without getting that positive feedback loop of seeing things come together. Some days are just a slog, and you have to accept that you’re laying foundations you can’t see yet. Today was definitely one of those.

Next: Focus on getting a barebones version of the video analysis POC working for the upcoming demo.

Tags: LLM, Video Analysis, Refactoring, POC, Debugging, Developer Log

My Epic Battle with yt-dlp, Bash, and a Mountain of YouTube JSON

Asaf Lecht | אסף לכט — Tue, 14 Oct 2025 00:00:00 +0000

I set out to build a “simple” script to pull metadata for Hebrew children’s videos from YouTube. The plan was to use yt-dlp, pipe the JSON output to Python for filtering, and save it all as a clean TSV. Turns out, “simple” was optimistic. The whole thing turned into a multi-day debugging marathon, especially trying to get everything working smoothly inside Git Bash on Windows.

Here’s a rundown of the biggest hurdles and what I learned.

Environment setup is half the battle. My minimal MINGW64 environment was missing everything: wget, sudo, jq, and stdbuf. I spent hours finding workarounds, like using curl instead of wget, creating a Bash wrapper for the jq.exe binary, and using PYTHONUNBUFFERED=1 to force real-time output when stdbuf wasn’t available.
yt-dlp can be a memory hog. When pulling from a massive channel playlist, yt-dlp tried to load the entire list of videos into memory before outputting anything, causing it to hang. The magic flags were --lazy-playlist and --flat-playlist, which process the playlist item by item, turning a firehose into a manageable stream.
Pipes are fragile. My script kept dying with “Broken pipe” or “Invalid argument” errors. The culprit? My Python script was consuming stdin for itself, leaving the piped data from yt-dlp with nowhere to go. The fix was to pass file paths as arguments to the Python script (python -c '...' "$OUT_FILE") instead of relying on the standard input stream.
Unicode filtering is your friend. My initial searches for Hebrew kids’ content returned a lot of irrelevant videos. The most effective fix was a simple Python function to check if the video title or uploader name contained any characters within the Hebrew Unicode range (\u0590–\u05FF). It was a surprisingly precise way to filter out the noise.

This was one of those side projects that spiraled, but it was a fantastic learning experience. Untangling the mess of shell environments, process buffering, and API quirks was a powerful reminder that even with great tools, the real work is getting them to talk to each other without tripping over their own feet.

Next: Now that the data extraction is reliable, I might try converting the videos to audio and using an LLM to help me review the content.

Tags: bash, python, yt-dlp, data-engineering, cli, debugging