How I Built Reusable Satellite Imagery Tools with Lium AI | My Experience

Table of Contents

I was sitting in my Hell's Kitchen apartment, staring at a 4.2-gigabyte GeoTIFF of central New York State. My task was simple: measure crop health indices across 200,000 acres of farmland using satellite imagery. Simple in theory. In practice, it meant downloading massive files, wrestling with GDAL commands I had to Google every single time, writing Python scripts that broke with every new image, and manually recalculating NDVI values like it was 1995.

The worst part? I knew I'd have to do it all over again next month when the new satellite pass came in.

Then I fed that same GeoTIFF into Lium AI and asked a single question: "Build me a reusable tool that automatically calculates NDVI, EVI, and NDWI for any Landsat-9 scene I upload, and exports the results as a CSV with geotags."

Twenty-three minutes later, I had a fully functional, reusable measurement tool that I could deploy on any new satellite image with zero additional coding.

This isn't a theoretical walkthrough. This is the exact workflow I used — the prompts that worked, the manual fixes I had to make, and the export process that turned this into a tool I've now used on 47 different satellite scenes without a single failure.

Project Metadata

• Project Goal: A reusable satellite imagery measurement tool that automatically calculates vegetation indices (NDVI, EVI, NDWI) from Landsat-9 scenes and exports structured CSV data with geographic coordinates.
• Tool Used: Lium AI (https://www.lium.ai) — built specifically for multimodal datasets like satellite imagery, seismic surveys, and scientific measurements that generic AI tools can't handle.
• Time Spent: 2.5 hours total (30 minutes of data prep, 45 minutes of prompt engineering, 1 hour of manual verification and tweaking, 15 minutes of export and documentation).
• Cost: $0 using the Free tier (10 messages included) — though I seriously considered upgrading to Pro at $30/month after seeing what this tool could do.

Why Lium Changed My Satellite Workflow Forever

Before Lium, my satellite imagery workflow was a Frankenstein monster of open-source tools held together by duct tape and prayers.

I'd download Landsat scenes from USGS EarthExplorer, spend hours converting formats, write fragile Python scripts using rasterio and numpy, debug for hours when something inevitably broke, and then repeat the entire process when a new image came in. Every. Single. Time.

Lium changed that because it was built for exactly this kind of work. The platform ingests raw satellite data — GeoTIFFs, raster layers, sensor streams — and structures them for AI systems to reason over. It's designed for scientists, analysts, and domain experts, not just engineers.

What sold me was Lium's ability to create reusable artifacts. The analysis I validate once becomes a sharable, deployable tool that my team can use on any new data. No more rewriting scripts. No more debugging the same GDAL errors. Just upload, run, and export.

The Data I Started With

Before I show you the prompts, let me be specific about what I was working with:

• One Landsat-9 scene — Path 15, Row 33, covering central New York State (about 4.2 GB)
• Band-specific GeoTIFFs — Band 2 (Blue), Band 3 (Green), Band 4 (Red), Band 5 (NIR), Band 6 (SWIR 1)
• Metadata file — MTL.txt with acquisition date, sun angle, and calibration coefficients
• A shapefile of the study area — 200,000 acres of agricultural land

All of these were in different formats. The GeoTIFFs were massive. The metadata was a dense text file. The shapefile was in a proprietary format that often breaks in open-source tools.

The Free tier only gives you 10 messages, so I knew I had to be strategic. I couldn't afford to waste prompts on bad questions.

Step 1: The Prep & The Prompt

Here's the thing about satellite imagery and AI: you can't just dump files and say "analyze this." The AI needs context about what each band represents, what indices you want to calculate, and what format you want the output in.

My prep workflow looked like this:

• Uploaded all seven files to Lium's workspace. The platform handled the GeoTIFFs without complaint — something that immediately impressed me.
• Named each band clearly — not "LC09_L2SP_015033_20240815_20240819_02_T1_SR_B4.TIF" but "Landsat_Band4_Red."
• Added a brief description in the dataset metadata: "Landsat-9 Surface Reflectance, Path 15 Row 33, August 15 2024."

Then came the prompt. I spent about 30 minutes iterating on this, and here's what finally worked:

My Exact Prompt (Lium Free Tier — Message #1):

I've uploaded a Landsat-9 scene (Path 15, Row 33, August 15 2024) with surface reflectance bands. Here's what I need: Input datasets: Band 2 (Blue) — 10m resolution Band 3 (Green) — 10m resolution Band 4 (Red) — 10m resolution Band 5 (NIR) — 10m resolution Band 6 (SWIR 1) — 10m resolution Study area shapefile — agricultural land boundaries Metadata file — MTL.txt with calibration data Build a reusable measurement tool that does the following: For each pixel in the study area, calculate: NDVI = (NIR - Red) / (NIR + Red) EVI = 2.5 * ((NIR - Red) / (NIR + 6 * Red - 7.5 * Blue + 1)) NDWI = (Green - NIR) / (Green + NIR) Apply the surface reflectance calibration coefficients from the metadata file. Export the results as a CSV with these columns: longitude, latitude (WGS84) ndvi_value, evi_value, ndwi_value acquisition_date Make this tool reusable — I should be able to upload any new Landsat-9 scene and run the same analysis without rewriting anything. Generate the complete tool and show me the results for this scene.

What happened next:

• Lium processed for about six minutes. The platform's compute provisioning kicked in automatically — I could see it spinning up resources to handle the raster processing.
• The initial output was... promising but incomplete. Lium gave me the NDVI, EVI, and NDWI calculations for about 85% of the study area. But there were gaps — pixels where the indices came back as null or NaN. The CSV export was there, but it was missing the geotags for about 15% of the pixels. And the tool's "reusability" was more theoretical than practical — it worked for this specific scene, but I could see it breaking with a different acquisition date or path/row.

This is where the "tweaking" part comes in.

The Tweaking Formula (When Your First Prompt Doesn't Work)

If you try this with your own satellite data and get mediocre results, don't panic. Here's the correction formula I've developed after testing this on three different Landsat scenes:

• The "Missing Pixels" Fix: If Lium is dropping pixels or returning NaN values, it usually means there's a mismatch between the raster resolution and the shapefile boundaries. Add this to your prompt: "For pixels that fall partially outside the study area boundary, use a 50% overlap threshold. Include only pixels where at least 50% of the pixel area falls within the shapefile."
• The "Calibration" Fix: If the index values look wrong (NDVI > 1 or < -1), the calibration coefficients might not be applying correctly. Be explicit: "Apply the reflectance scaling factor from the metadata file (REFLECTANCE_MULT_BAND_n and REFLECTANCE_ADD_BAND_n). Convert digital numbers to top-of-atmosphere reflectance before calculating indices."
• The "Reusability" Fix: If the tool only works for this specific scene, you need to make the metadata dynamic. Add this: "Instead of hardcoding the acquisition date and calibration coefficients, read them from the MTl.txt file that's uploaded with each new scene. Make the tool accept any Landsat-9 scene as input."

Here's my revised prompt (Message #2, after the first one gave me incomplete results):

The Magic Prompt (Lium Free Tier — Message #2):

Great start, but there are gaps in the output and the reusability needs work. Let me be more specific. Fixes needed: For pixels on the study area boundary: use a 50% overlap threshold. Include pixels where ≥50% of the pixel area falls inside the shapefile. Apply reflectance calibration correctly: For each band, read REFLECTANCE_MULT_BAND_n and REFLECTANCE_ADD_BAND_n from the MTl.txt file Convert DN to reflectance: reflectance = DN * mult + add Then calculate indices using reflectance values Make the tool fully reusable: The tool should accept any Landsat-9 scene as input Read acquisition date, path, row, and calibration coefficients from the metadata file dynamically No hardcoded values For the CSV export, include: longitude, latitude (WGS84, 6 decimal places) ndvi, evi, ndwi (4 decimal places) acquisition_date (YYYY-MM-DD format) pixel_quality (a simple flag: 'good' if all indices valid, 'marginal' if one index invalid, 'poor' if two or more invalid) Re-run the analysis with these specifications and show me the complete results.

This time, the output was clean. The gaps were filled. The calibration was correct. The CSV had all the columns I wanted, and the pixel_quality flag gave me a quick way to filter out bad data. The tool was now genuinely reusable — I tested it with a different Landsat scene (Path 16, Row 32) and it worked perfectly without any modifications.

But here's the part I have to be honest about: the CSV export had a formatting quirk. The longitude and latitude columns were reversed in about 2% of the rows. And the pixel_quality flag wasn't always accurate — some pixels flagged as 'good' had clearly anomalous NDVI values.

That's when I realized I needed to step in manually.

Step 2: The Human Polish (Where I Had to Step In)

The CSV looked great at first glance. 47,283 rows of NDVI, EVI, and NDWI data. All the columns I asked for. A pixel_quality flag that seemed reasonable.

But when I started spot-checking the data against known reference points, I found three issues that needed manual correction.

Issue #1: The reversed coordinate problem.

About 2% of the rows had longitude and latitude swapped. Not a huge percentage, but enough to cause problems if I was doing spatial analysis downstream. I traced this back to a quirk in how Lium read the GeoTIFF's coordinate reference system — it occasionally misinterpreted the CRS order.

How I fixed it: I wrote a quick Python script that checked each row's coordinates against the study area boundary. If a point fell outside the bounding box, I assumed the coordinates were swapped and corrected them. This caught 100% of the errors.

Issue #2: The pixel_quality flag was too optimistic.

Some pixels flagged as 'good' had NDVI values above 1.0 or below -1.0 — which is physically impossible for healthy vegetation. The AI's quality check wasn't rigorous enough.

How I fixed it: I manually filtered the CSV to remove any rows where NDVI > 1.0 or < -1.0. I also added a secondary quality flag: "geometrically_valid" that checked for reasonable index ranges. This reduced my usable dataset from 47,283 to 43,891 rows — but the data I kept was clean and trustworthy.

Issue #3: The calibration edge case.

Lium applied the reflectance calibration correctly for most pixels. But about 3% of pixels — mostly in shadowed areas and cloud edges — had calibration values that were slightly off. The AI didn't flag these as errors.

How I fixed it: I manually overlaid the results with the original imagery and identified the problematic areas. For these pixels, I recalculated the indices using a simpler method (top-of-atmosphere reflectance without the full calibration). This wasn't as accurate, but it was better than the AI's corrupted values.

This took me about an hour. Was it frustrating? A little. But here's the thing — without Lium, I would have spent three days just getting the data into a usable format. These corrections were tweaks, not overhauls.

The Golden Rule of Satellite Imagery AI Workflows

Always, always verify the AI's output against a known reference point.

I used a 100-acre test plot with known vegetation characteristics to spot-check my results. If your NDVI values don't match expected ranges for your study area, don't assume the AI is right. Lium is powerful, but it's not omniscient. It processes what you give it — and sometimes it processes it imperfectly.

For my final run, I fed the corrected data back into Lium with a follow-up prompt to generate the final tool package.

Follow-up Prompt (Message #3 — after manual corrections):

I've corrected the coordinate and calibration issues. Now package this as a complete reusable tool: Include the corrected calculation logic Add a data validation step that flags pixels with unrealistic NDVI values Generate documentation explaining how to use the tool with new Landsat-9 scenes Package everything as a downloadable artifact The tool should be ready for deployment on any new scene.

This time, the output was flawless. The tool included validation logic, clear documentation, and a simple deployment process. I've now used it on 47 different Landsat scenes without a single failure.

Step 3: Exporting the Final Object

Lium makes exporting straightforward, but there are a few things worth knowing.

The Export Workflow:

• From the workspace dashboard, locate your completed tool artifact. Lium saves outputs — analyses, scripts, charts, datasets — as shared workspace artifacts that your team can reuse.
• Click the export button on the artifact. You'll see a dropdown of supported formats. For this satellite imagery tool, the key options were:
  • Python Script (*.py) — the complete tool as a standalone Python script with all dependencies
  • Jupyter Notebook (*.ipynb) — the tool packaged as an interactive notebook for easy testing
  • Documentation (*.md) — usage instructions and API reference
  • CSV Export — the results of the current analysis
• Select your export format. I exported as both a Python script and a Jupyter Notebook. The script is better for automated workflows, while the notebook is ideal for testing new scenes.
• Download and test. I downloaded the Python script, ran it on a new Landsat scene (Path 16, Row 32), and verified it worked without modifications. It did.

One thing to watch: The Free tier limits you to 10 messages total. I used three messages for the initial analysis, one for the corrected run, and two for documentation and packaging. That left me with four messages to spare. If you're building complex tools and expect to iterate heavily, the Pro tier at $30/month is worth every penny.

The Prompt Engineering Matrix

Object Style/Goal	My Exact Prompt	Result Quality
Precise Technical	"Build a tool that calculates NDVI, EVI, and NDWI using Landsat-9 surface reflectance bands. Apply calibration from metadata. Export CSV with longitude, latitude, and index values. Include a 50% overlap threshold for boundary pixels."	Excellent. Clean tool, correct calibration, complete CSV, fully reusable.
Vague/Exploratory	"Analyze this satellite data and tell me about vegetation health."	Poor. Lium generated a generic summary with some basic statistics. No tool, no structured output, no reusability.
Visual-First	"Create a nice vegetation map I can show to stakeholders."	Mediocre. Lium produced a heatmap visualization but the underlying data was incomplete. The AI prioritized aesthetics over accuracy.
Iterative Refinement	"Great start, but the CSV has gaps. Here's my exact schema: longitude, latitude, ndvi, evi, ndwi, acquisition_date, pixel_quality. Re-run with these specifications."	Excellent. The second pass fixed all issues. This is the approach I recommend.

Comparison Table by Tier

Tier	Generation Speed	Output Results	Set Limit	Revisions/Edits Needed?
Free Tier	~6 minutes for the initial tool build	Complete but required manual correction of coordinate errors and pixel_quality flags	10 messages total	Yes — needed to correct ~2% coordinate errors, recalculate ~3% calibration edge cases, and validate pixel_quality flags
Pro Tier ($30/month)	~4 minutes (faster compute provisioning)	Clean output with accurate coordinates and better calibration handling	Unlimited messages	Minimal — only minor edge-case tweaks needed

My take: The Free tier is great for prototyping and small projects. But if you're building tools you'll use repeatedly on production data, upgrade to Pro. The time you save on corrections alone justifies the $30/month.

Project Cost: AI vs. Hiring a Human

Let's run the numbers.

Hiring a remote sensing specialist in New York:

• Average rate: $100–$200/hour
• Time estimate for this project: 2–4 days (16–32 hours)
• Total cost: $1,600–$6,400

Using Lium AI (Pro tier):

• Subscription: $30/month
• My time: 2.5 hours (at my consulting rate of $150/hour = $375)
• Total cost: $405

The verdict: Lium is dramatically cheaper — about 80–90% less than hiring a human specialist. But here's the nuance: I wouldn't trust Lium's output without manual validation. The AI got me 90% of the way there in minutes, but that final 10% — the corrections, the edge cases, the domain expertise — still required a human touch.

For straightforward satellite imagery work with clean data, Lium is a no-brainer. For research-grade analysis where accuracy is critical, use Lium as a force multiplier, not a replacement for human expertise.

The Usability Verdict for Satellite Imagery Measurement Tools

Free Tier Rating: 6/10
The Free tier gets you in the door, but the 10-message limit is tight for complex tool-building. I burned through six messages just getting the initial tool right, plus documentation and packaging. If you're prototyping, it's fine. For anything you'll use repeatedly, upgrade.

Pro Tier Rating: 8.5/10
The Pro tier is where Lium shines. Faster compute, unlimited messages, and expanded integrations make a tangible difference. The tool quality is excellent — but you still need to validate the outputs.

Overall Rating for This Specific Object: 8/10
Lium is genuinely impressive for building reusable satellite imagery tools. It handles GeoTIFFs, applies calibration, and exports structured data in minutes. But it's not magic. The AI will make subtle errors with messy data, and you need the domain expertise to catch them.

What frustrates me: The coordinate reversal bug was a subtle error that could have gone unnoticed. Lium doesn't flag uncertainties — it just presents everything with equal authority. That's dangerous if you're not paying attention.

What excites me: When Lium works, it really works. The speed at which it can build a reusable tool that I've now used on 47 different scenes is genuinely remarkable. For $30/month, it's a steal.

FAQ: Intercepting Field Obstacles

Can I use Lium with my own satellite imagery formats?

Yes. Lium is built specifically for messy, domain-specific formats — GeoTIFFs, satellite imagery, sensor streams, and scientific measurements. If you can upload it, Lium can probably process it.

How much data can I throw at Lium on the Free tier?

The Free tier supports limited data connections and standard queries. For my 4.2GB Landsat scene plus six bands and metadata, it handled everything fine. But if you're working with multiple scenes or higher-resolution imagery, you'll need the Pro tier's expanded integrations.

My CSV export is missing columns. What do I do?

This happened to me on the first pass. The fix is to be extremely specific in your prompt about the exact schema you want. Don't say "include the indices" — say "include longitude, latitude, ndvi, evi, ndwi, acquisition_date, and pixel_quality as columns."

How accurate are Lium's vegetation indices?

In my testing, about 95% accurate on the first pass. The remaining 5% required manual correction — usually due to coordinate issues or calibration edge cases that the AI didn't handle gracefully.

Can Lium replace a remote sensing specialist?

No. Lium is a powerful assistant that can do 80–90% of the grunt work in minutes. But you still need a human with domain expertise to validate the output, catch errors, and make judgment calls.

Will the tool work with imagery from other satellites (Sentinel, SPOT, etc.)?

The tool I built was specifically for Landsat-9. But the logic is adaptable. If you give Lium the band specifications for Sentinel-2 or SPOT, it can build a similar tool. Just be specific about the bands and calibration requirements.

The Final Call: Would I Do It Again?

Absolutely. In fact, this tool has become a cornerstone of my workflow. I've now used it on 47 different Landsat scenes across three different study areas. Each time I run it, the process takes minutes instead of days.

Here's what I'd tell a colleague considering Lium:

• If you're working with satellite imagery, sensor data, or any complex scientific dataset, Lium is worth every penny of that $30/month. It won't replace your expertise, but it will 10x your productivity.
• Just don't trust it blindly. Verify everything. Spot-check the outputs. And always, always keep a human in the loop.

Your Turn

Now I want to hear from you.

Have you tried Lium for satellite imagery analysis? What tools are you building? Did you run into the same coordinate reversal issue I did, or did you hit different pain points?

Drop your experience in the comments below. I read every single one, and I'll respond to as many as I can. If there's enough interest, I'll write a follow-up covering advanced techniques — multi-scene mosaicking, time-series analysis, and integration with ground-truth data.

Until then, happy mapping.