DEV Community: JOYSTON

Frame-Chaining AI Video: Building a 60-Second Film with GMI Cloud

JOYSTON — Tue, 27 Oct 2026 03:49:55 +0000

I wanted to create a 60-second cinematic FPV travel film across the United States, moving from New York to San Francisco and Los Angeles.

The goal wasn't simply to generate impressive AI footage. I wanted the entire film to feel like one continuous drone journey rather than a collection of unrelated clips stitched together in post-production.

That introduced three practical challenges:

Maintaining visual continuity across independently generated clips.
Controlling camera movement, lighting, and transitions through prompts.
Fixing individual shots without regenerating the entire video.

I built the film using GMI Cloud's video generation models, frame chaining, and FFmpeg.

The final output was exactly 60 seconds long, rendered at 1080p, with a targeted replacement for a shot that generated incorrectly.

Here's how the pipeline worked, including the API issues, failed generations, and techniques that made the workflow more reliable.

1. Understanding the Duration Constraint

The first step was checking the available models and their actual generation limits.

Rather than relying on model names or assumptions, I used GMI Cloud's get_model tool to inspect the supported parameters, duration limits, and pricing.

get_model({ model_id: "seedance-2-5-260628" })
get_model({ model_id: "wan3.0-video" })
get_model({ model_id: "veo-3.1-generate-001" })

The following figures reflect the catalog and pricing I observed during development in October 2026. Verify them against the current catalog before using them in production.

Model	Maximum duration	Observed 1080p price/sec	Relevant capabilities
`seedance-2-5-260628`	30 seconds	$0.569	First-frame and last-frame conditioning, reference images, audio generation
`wan3.0-video`	30 seconds	$0.20	Frame conditioning, reference images, separate negative prompt
`veo-3.1-generate-001`	8 seconds	$0.40	High photorealism, two-frame conditioning
`kling-3.0-turbo-t2v`	15 seconds	$0.14	Text-to-video generation
`seedance-2-0-260128-upscale`	15 seconds	$0.056	Budget-oriented option
`veo-3.1-lite-generate-001`	8 seconds	$0.05	Lower-cost generation at supported resolutions

These capabilities and prices are model- and configuration-dependent. Check the current API schema before building around a particular parameter.

The key constraint was straightforward: no model in this selection could generate the entire 60-second film in one request.

I therefore split the project into two 30-second generations.

Fewer, longer clips reduce the number of boundaries that need to be managed. A six-clip pipeline introduces five joins, while a two-clip pipeline introduces just one.

However, clip length shouldn't be the only consideration. The structure of the film matters, too. If a story naturally contains three distinct locations or sequences, three shorter clips may be easier to control than two longer generations.

The objective is to minimize unnecessary joins without forcing unrelated scenes into one generation.

2. Prompt Engineering: Control the Camera Before the Scene

One of the biggest lessons from this project was that a video prompt needs to describe motion, not just visual content.

My initial prompts combined several events into short sequences:

Dive between skyscrapers.
Sweep toward the Hudson River.
Transition from sunrise to blue hour.
Race through city streets.
Introduce light trails.

The results were inconsistent. Architecture distorted, transitions became muddy, and the camera sometimes appeared to blend incompatible locations.

The problem was trying to control too many independent events in a single prompt.

My revised approach was to define a continuous camera movement with explicit scene timing.

The single-movement principle

Describe one continuous camera journey per generation, and use FFmpeg for editorial cuts.

This doesn't mean a longer generation must contain only one location. It means the transitions between locations should follow a physically understandable camera movement rather than asking the model to perform several unrelated edits.

For example, an aircraft wing can pass across the lens and temporarily obscure the entire frame. The next location can emerge as the wing clears.

That provides a visual transition the model can attempt to render as part of the camera movement.

Here's an excerpt from the prompt used for the film:

Ultra-realistic cinematic FPV drone travel film, 30 seconds, 16:9.

One continuous high-speed journey across the United States.
Maintain forward camera momentum throughout.

Photorealistic imagery, consistent teal-and-orange commercial
color grading, high dynamic range, natural film grain,
subtle horizontal anamorphic lens flare, and a wide 14mm lens.

Use smooth motion blur only during the fastest movements.

No text, captions, subtitles, logos, watermarks, or readable
signage.

SHOT 1 (0-7s):
Above New York City at sunrise. Low mist surrounds the
skyscrapers as the drone tips forward and dives between
glass towers. Golden light reflects across the facades.

SHOT 2 (7-15s):
The camera descends to street level and races down a wide
Manhattan avenue. Moving cars pass beneath the camera,
their headlights and taillights creating flowing light trails.

SHOT 3 (15-22s):
The drone rises over New York Harbor. A ferry crosses the
water below, leaving a white wake. The camera sweeps around
to reveal the Statue of Liberty in the morning haze.

SHOT 4 (22-30s):
An aircraft wing passes directly across the lens, filling
the frame. As it clears, the camera emerges above turquoise
Pacific water near San Francisco, moving toward the Golden
Gate Bridge as its red towers appear through coastal fog.

The timing provides structure, but it doesn't guarantee that the model will follow every boundary precisely. Treat shot durations as guidance and inspect the generated footage before editing.

Keep the visual identity consistent

Consistency doesn't require identical lighting throughout the film.

The sequence moves between sunrise, daylight, golden hour, and night. Those changes are part of the story.

What should remain relatively stable is the visual treatment:

Color grading.
Lens characteristics.
Motion style.
Contrast and highlight handling.
Overall level of realism.

I repeated the same visual descriptors across prompts while allowing the lighting and environment to change.

This gave the film a more consistent look without making every location feel artificially identical.

Negative prompts are model-specific

Different models expose different controls.

For example, wan3.0-video supports a dedicated negative_prompt parameter, while the Seedance 2.5 configuration I used did not expose that parameter.

For Seedance, I placed unwanted elements directly in the prompt:

No text, captions, subtitles, logos, watermarks, or readable
signage anywhere in the frame.

The general lesson is to inspect the actual model schema rather than assume that every video model supports the same parameters.

3. Frame Chaining: Maintaining Continuity Between Clips

Frame chaining was the central technique in this project.

Instead of generating two unrelated clips and trying to hide their differences afterward, I used the final frame of the first clip to condition the beginning of the second.

The pipeline is simple:

Generate clip A.
Extract a frame near the end of clip A.
Upload the frame to GMI Cloud.
Pass its URL as the first_frame parameter when generating clip B.
Inspect the boundary and adjust the edit if necessary.

The second generation now has a visual reference for where the first generation ended.

Extracting the frame with FFmpeg

I extracted a frame near the end of the first clip:

ffmpeg -y -ss 29.9 -i clipA.mp4 \
  -frames:v 1 chain_last.png

I then normalized the image to the intended output dimensions and converted it to JPEG:

ffmpeg -y -i chain_last.png \
  -vf "scale=1920:1080:force_original_aspect_ratio=increase,crop=1920:1080" \
  -q:v 3 chain_first.jpg

The output dimensions should match the intended video aspect ratio. If the source frame already has the correct dimensions, unnecessary scaling and cropping can be avoided.

The extracted image becomes the conditioning frame for the next generation.

Uploading the frame to GMI Cloud

The upload_media operation returns a signed upload_url and a public_url.

These serve different purposes:

upload_url is the destination for uploading the file.
public_url is the image URL supplied to the video generation request.

The signed URL doesn't upload the file automatically. You must send the image bytes to it.

Here's a minimal Python example:

import urllib.request

upload_url = "<upload_url from upload_media>"

with open("chain_first.jpg", "rb") as image_file:
    image_data = image_file.read()

request = urllib.request.Request(
    upload_url,
    data=image_data,
    method="PUT",
    headers={"Content-Type": "image/jpeg"},
)

with urllib.request.urlopen(request) as response:
    print(response.status)

Use the URL and HTTP method specified by the upload operation. If the signed URL expires or the upload returns a signature error, request a fresh URL and retry.

I encountered a 403 SignatureDoesNotMatch error with an earlier upload URL. Requesting a new URL resolved the problem in my case.

Generating the next clip

With the frame uploaded, I passed its public URL to Seedance 2.5.

The following is a representative request structure; use the exact field names and request envelope documented by the current API.

{
  "model_id": "seedance-2-5-260628",
  "prompt": "<your scene and camera-movement prompt>",
  "parameters": {
    "duration": 30,
    "resolution": "1080p",
    "ratio": "adaptive",
    "first_frame": "<public_url of chain_first.jpg>",
    "generate_audio": true,
    "watermark": false
  }
}

The critical setting was ratio.

The `ratio` configuration issue

I encountered failed generations when using an explicit ratio: "16:9" and when omitting the ratio entirely.

The API returned an error explaining that, when first-frame or first-and-last-frame conditioning is used, the output aspect ratio follows the input frame.

The configuration that worked was:

"ratio": "adaptive"

For this particular model configuration, using ratio: "adaptive" resolved the issue.

Don't assume that a parameter's default value is valid for every generation mode. Frame-conditioned generation can have different validation rules from text-to-video generation.

Verify this behavior against the current API documentation before relying on it in another model version.

What frame chaining actually guarantees

Frame chaining is useful, but it is important to distinguish three different forms of continuity.

Frame continuity: The next generation receives a reference image matching the preceding clip's endpoint.

Temporal continuity: Camera motion, object movement, lighting, and perspective evolve naturally across the boundary.

Subject continuity: People, vehicles, and other objects maintain their identity and appearance across shots.

Frame chaining primarily addresses the first problem. It can help with the second, but it doesn't guarantee a perfect motion transition. It also doesn't guarantee subject consistency across independently generated scenes.

A matching boundary frame is not proof that the surrounding motion will be seamless.

For recurring subjects, combine frame conditioning with reference images where the model supports them.

Model	Reference parameter	Observed catalog limit
`wan3.0-video`	`reference_image`, `reference_video`	Up to 10 images and 5 videos
`seedance-2-5-260628`	`reference_images`, `reference_videos`	Up to 9 images and 3 videos
`happyhorse-1.1-r2v`	`reference_image`	Up to 5 images

These limits are model-specific and should be verified before use.

I also found that frame chaining works best when the next clip continues a compatible scene.

A coastline transitioning into a bridge approach provides a natural continuation. A sudden jump from San Francisco to a Los Angeles street is a different editorial event and is often better handled as a deliberate cut.

Chain compatible camera movements. Use editing to handle genuine changes in scene or location.

4. Stitching the Film with FFmpeg

Once the clips were generated, I assembled them into the final video.

For a simple join, FFmpeg's concat demuxer is convenient when the input files have compatible stream properties.

Create a file named list.txt:

file 'clipA.mp4'
file 'clipB.mp4'

Then concatenate the clips:

ffmpeg -y -f concat -safe 0 -i list.txt \
  -t 60.0 \
  -vf "fps=24,scale=1920:1080:flags=lanczos,format=yuv420p" \
  -c:v libx264 -preset slow -crf 17 \
  -c:a aac -movflags +faststart \
  out/master.mp4

This example assumes that the input streams are compatible with the chosen filter and encoding pipeline. Incompatible codecs, time bases, resolutions, or audio streams may require normalization before concatenation.

The command also re-encodes the video, so it is not a lossless join.

When the clips need different processing

For the final replacement, I needed to combine a 50-second section of the existing master with a newly generated 10-second clip.

I used a filter graph to concatenate the video and audio streams while normalizing the video output:

ffmpeg -y -i head.mp4 -i clipFix.mp4 \
  -filter_complex \
  "[0:v][1:v]concat=n=2:v=1:a=0,fps=24,scale=1920:1080:flags=lanczos,format=yuv420p[v]; \
   [0:a][1:a]concat=n=2:v=0:a=1[a]" \
  -map "[v]" -map "[a]" \
  -t 60.0 \
  -c:v libx264 -preset slow -crf 17 \
  -profile:v high -level 4.2 \
  -c:a aac -b:a 192k \
  -movflags +faststart \
  out/america_60s_16x9_v2.mp4

This version assumes both inputs contain compatible audio streams. If one clip lacks audio, the filter graph needs to be adjusted to create or omit the missing stream.

Also, -t 60.0 limits the output duration; it doesn't independently guarantee that the final file contains exactly 60 seconds of usable footage.

To verify the result, inspect the actual duration and frame count.

ffprobe -v error \
  -show_entries format=duration \
  -of default=noprint_wrappers=1:nokey=1 \
  out/america_60s_16x9_v2.mp4

For a 24 fps output, 60 seconds corresponds to 1,440 frames. Checking both duration and frame count is useful when exact delivery specifications matter.

Creating a cinematic 2.39:1 presentation

The source video was generated at 16:9, but I also wanted to test a wider cinematic presentation.

One option is to scale the image to 1920 × 804 and add black bars to restore a 1920 × 1080 canvas:

ffmpeg -y -i master.mp4 \
  -vf "scale=1920:804:flags=lanczos,pad=1920:1080:0:138:black" \
  -c:v libx264 -preset slow -crf 17 \
  -profile:v high \
  -c:a copy \
  -movflags +faststart \
  out/master_239.mp4

This produces an approximately 2.39:1 image area within a 16:9 video frame.

Letterboxing preserves the entire scaled image, unlike a direct vertical crop that discards parts of the original frame.

However, scaling the full 16:9 image to 1920 × 804 changes its proportions unless the image is cropped first. For a geometrically correct widescreen presentation, use a crop-and-scale pipeline when necessary.

5. Re-Rendering One Bad Shot Instead of the Entire Film

One of the most useful aspects of this workflow was the ability to replace a specific segment without rebuilding the whole video.

During generation, the Hollywood sign appeared as "HOLFWOOD" instead of "HOLLYWOOD".

This is a familiar limitation of generative video models: text can look convincing at a glance while individual characters remain incorrect or unstable.

Regenerating the entire 60-second film would have wasted both time and credits.

Instead, I extracted the frame at the replacement boundary, used it as the new clip's first_frame, and generated a replacement segment.

ffmpeg -y -ss 50.0 -i out/master.mp4 \
  -frames:v 1 splice_first.jpg

After uploading the frame and generating the replacement clip, I rebuilt the master from the unchanged opening section and the new footage.

The replacement was approximately 10 seconds long.

Prompting for accurate text

For the replacement, I made the lettering requirement explicit:

CRITICAL: The hillside sign must read exactly HOLLYWOOD.

The spelling is H-O-L-L-Y-W-O-O-D: nine letters.

The fourth letter must be L, not F.

The letters are large, white, individually formed capital
letters arranged in a straight horizontal line on a dry,
brown hillside.

Keep the lettering stable, correctly formed, and clearly
visible from the front. Do not distort, rearrange, or replace
any characters.

The revised generation produced the intended spelling.

This doesn't mean literal prompts can reliably solve text rendering in every model. It means a specific description of the expected output and known failure can improve the next attempt.

For shots containing signs, product labels, or other critical text, I recommend treating one or two targeted re-renders as part of the production budget.

When exact typography is essential, a more reliable approach is to add the text during post-production rather than depend on the video model to render it correctly.

6. Practical Issues I Encountered

The creative workflow was only part of the implementation. Several API and environment issues also affected the process.

Keep generation parameters in the expected structure

My generation-estimation requests required model-specific parameters to be nested under parameters.

For example:

{
  "model_id": "seedance-2-5-260628",
  "prompt": "<prompt>",
  "parameters": {
    "duration": 30,
    "resolution": "1080p",
    "ratio": "adaptive"
  }
}

Use the structure expected by the relevant operation. An estimation endpoint and a generation endpoint may not accept identical request bodies.

An MCP timeout doesn't necessarily mean generation failed

One submit_generation request timed out on the client side while the server-side generation continued running.

Submitting the same request again could have created unnecessary work or additional charges.

Instead, I used list_generations to inspect the existing jobs and recover their status.

For production systems, keep track of generation IDs, request parameters, and job status. When supported, use idempotency controls to distinguish intentional re-renders from accidental duplicate submissions.

Check which credits apply to each model

My account displayed a zero-dollar balance alongside promotional credits. One model returned an insufficient_balance error, while another accepted the request.

This was an account-specific result, not proof that all promotional credits are restricted in the same way.

Before running a large batch, verify that the available credits apply to the selected model and generation configuration.

Verify your FFmpeg version

My system FFmpeg installation was too old to handle the HEVC Main10 output produced by the video model.

The resulting codec errors initially looked like a problem with the downloaded file.

I installed a newer FFmpeg binary through imageio-ffmpeg:

pip install imageio-ffmpeg

Then I checked the binary path:

python -c "import imageio_ffmpeg; print(imageio_ffmpeg.get_ffmpeg_exe())"

Use a sufficiently recent FFmpeg build with the codecs required by your source footage.

For reproducible workflows, check the installed version and codec support before beginning a batch of generations.

Verify audio instead of trusting the response

Although I requested audio generation, both clips returned valid AAC audio streams that were effectively silent.

I checked the audio levels with:

ffmpeg -i clip.mp4 \
  -af volumedetect \
  -f null - 2>&1 | grep -E "mean_volume|max_volume"

A valid audio stream doesn't necessarily contain audible sound. Inspect the output and listen to the actual result before delivery.

Separate language-model usage from media-generation costs

The account-summary information I inspected reported language-model usage separately from image and video generation.

Don't treat an LLM token-cost report as a complete accounting of a media-generation project.

Track the actual generation requests and their associated charges, and reconcile them against the relevant billing information.

7. Cost Breakdown

The final film used two 30-second clips and one 10-second replacement.

Generation	Duration	Observed cost
Clip A — Seedance 2.5, 1080p	30 seconds	$17.07
Clip B — Seedance 2.5, 1080p, frame-conditioned	30 seconds	$17.07
Replacement clip — Seedance 2.5, 1080p	10 seconds	$5.69
Total	70 generated seconds	$39.83

The total cost was $39.83 for a final 60-second film.

Notice that the generation duration adds up to 70 seconds, not 60. The extra 10 seconds came from replacing the incorrect segment.

The effective cost was approximately $0.66 per second of finished video.

These figures reflect the pricing and usage observed during this project. They exclude any additional costs not reflected in the recorded generation charges.

A lower-cost model may make experimentation more affordable, but cheaper generation can also require additional attempts to reach the desired visual quality.

The right choice depends on the importance of photorealism, continuity, generation speed, and budget.

Budget for re-renders from the beginning. A pipeline that assumes every generated shot will be usable is likely to underestimate its actual cost.

8. Scaling the Pipeline Beyond 60 Seconds

The same approach can be extended to longer films.

At a maximum of 30 seconds per clip:

Final duration	Number of clips	Number of joins
60 seconds	2	1
3 minutes	6	5
5 minutes	10	9
10 minutes	20	19

These counts assume full-length 30-second clips. Shorter clips may be more appropriate when the story contains distinct scenes or requires tighter control.

Each additional join creates another opportunity for mismatched motion, lighting, composition, or subject appearance.

Several practices make a longer pipeline easier to manage.

Choose boundary frames deliberately

Don't extract the final frame automatically without checking it.

Look for a frame where the camera is passing behind an object, approaching a new landmark, or entering a natural visual transition.

These moments can make an editorial boundary less noticeable.

However, the extracted frame should also provide a useful starting composition for the next generation. A visually interesting boundary is not necessarily a good conditioning frame if the next scene cannot continue naturally from it.

Preserve intermediate frames and generation metadata

Archive the conditioning frame used for every clip, along with:

The original prompt.
Model ID and generation parameters.
Generation job ID.
Source and output file paths.
Cost and duration.
Notes about failed attempts.

If clip 4 needs to be regenerated, the saved endpoint from clip 3 allows you to reproduce its starting condition without rebuilding the earlier footage.

This makes the workflow easier to debug and maintain.

Parallelize independent generations

Once the necessary reference frames are available, independent segments can be generated concurrently.

A fully sequential chain cannot be generated entirely in parallel because each clip may depend on the preceding clip's output.

A practical compromise is to divide the film into sequences that can be generated independently, then chain clips within each sequence.

Use idempotency controls where supported, and check the job list before retrying a timed-out request.

Make every segment independently replaceable

Treat each generated clip as a separate production asset.

The master video should be a reproducible output of the individual segments and the editing pipeline, not the only copy of the project.

That allows a single failed shot to be replaced without rebuilding the entire film.

9. Visual Verification Before Delivery

A successful API response doesn't mean the video is ready to publish.

I used FFmpeg to extract representative frames from across the timeline and assemble them into a contact sheet.

This made it easier to identify changes in visual style, unexpected objects, and problems with transitions.

For example, to inspect eight points in the film:

mkdir -p keys

for t in 1 9 17 25 33 41 49 58; do
  ffmpeg -y -ss "$t" -i out/master.mp4 \
    -frames:v 1 \
    -vf "scale=470:-1" \
    "keys/m_${t}.jpg"
done

The individual frames can then be assembled into a contact sheet.

A contact sheet is useful for reviewing the overall visual progression, but it won't reveal every temporal artifact.

For that, inspect the actual footage around each join, preferably frame by frame or at reduced playback speed.

For the Hollywood sign, I also extracted frames at half-second intervals to check whether the lettering remained stable throughout the replacement segment.

This helped distinguish incorrect lettering from frames where the sign was partially visible or viewed at an angle.

My final verification checklist included:

[ ] Confirm the final duration and frame rate.
[ ] Inspect every join for jumps in camera position or motion.
[ ] Check lighting, color grading, and scene continuity.
[ ] Review text, faces, architecture, and other high-risk details.
[ ] Verify audio levels and playback.
[ ] Confirm the output resolution and encoding.
[ ] Play the final exported file from beginning to end.

The model generates the footage. The editing and verification pipeline determines whether it is ready to ship.

Conclusion

Building a continuous AI-generated film is not just a prompting problem. It is a pipeline problem involving generation limits, frame conditioning, asset management, editing, and quality control.

For this project, frame chaining provided a practical way to connect separately generated clips while keeping each segment independently replaceable.

The most important lessons were:

Check model capabilities before designing the pipeline. Generation limits and parameter support determine how the film should be structured.
Describe camera movement explicitly. A coherent camera path is easier to manage than a prompt containing unrelated transitions.
Use frame chaining for continuity. The previous clip's endpoint provides a visual starting condition for the next generation.
Keep the pipeline modular. Replace failed segments rather than regenerating the entire film.
Verify the actual output. Inspect the joins, text, audio, duration, and final encoding.
Budget for failed generations. Re-renders are part of the workflow, not an unexpected exception.

The final film cost $39.83 in recorded generation charges and required 70 seconds of generated footage to produce 60 seconds of finished video.

The broader takeaway is that AI video generation becomes more manageable when treated as a reproducible media pipeline rather than a sequence of isolated prompts.

Frame chaining won't eliminate every continuity problem, but it gives you a useful degree of control over how separately generated footage fits together.

Model capabilities, parameter support, and pricing are subject to change. The figures in this article reflect observations from October 2026. Check the current GMI Cloud model catalog and API documentation before implementing the workflow.

I Tried Shorebird and Finally Understood Why Flutter Developers Keep Talking About It

JOYSTON — Sat, 13 Jun 2026 13:54:50 +0000

One thing that always annoyed me in mobile development is how long a simple fix can take to reach users.

You find a bug.

You fix the bug.

You build again.

You upload again.

Then… wait.

Sometimes for hours. Sometimes longer.

Coming from web development where changes can go live quickly, mobile releases always felt slower than they should be.

Recently I came across Shorebird, and after understanding how it works, I can see why people are excited about it.

If you build Flutter apps, this is probably worth knowing about.

The problem isn’t writing code — it’s shipping it

Imagine this.

Your app is already live.

Someone reports:

“The submit button doesn’t work.”

The actual fix takes 5 minutes.

But releasing it?

That’s a different story.

Normally the process looks something like:

Fix the issue
Generate a new build
Upload to Play Store / App Store
Wait for approval
Wait for users to update

For a tiny issue, that process feels heavy.

That’s exactly the problem Shorebird tries to reduce.

So what exactly is Shorebird?

Shorebird lets Flutter developers push certain updates to already-installed apps without publishing a completely new app release every time.

The first version still goes through the app store normally.

After that, when you make eligible Flutter code changes, Shorebird can send those updates directly to users.

When I first read about it, my reaction was:

“Wait… so this is basically faster app updates?”

That’s the simple explanation.

The part I found interesting

Instead of shipping the whole application again, Shorebird creates a patch.

Meaning:

If you changed 20 lines of Dart code…

you’re not rebuilding and redistributing everything.

You’re only sending what changed.

That idea feels obvious once you see it.

Example

Let’s say you release Version 1.0.

A few hours later users start saying:

“Dark mode crashes.”

You fix it.

Normally:

flutter build
upload
wait

With Shorebird:

shorebird patch

Users can receive that update much faster.

That part feels closer to deploying a website than releasing a mobile app.

Things it doesn’t magically solve

This was something I misunderstood initially.

Shorebird doesn’t replace app stores.

You still need normal releases for things like:

Native Android changes
Native iOS code updates
Permission changes
SDK upgrades
Store listing updates

It mainly helps with Flutter-side changes.

Still useful—but good to know before going in expecting instant updates for everything.

Where I think this makes the most sense

After looking into it, I think Shorebird fits best if:

You ship frequently
You maintain production Flutter apps
You hate waiting for tiny fixes
You already use CI/CD

If your app rarely changes, maybe the benefit isn’t huge.

But for teams pushing updates often, I can see why people adopt it.

Final thoughts

I’m not saying Shorebird suddenly makes mobile deployment perfect.

But I do think it removes one of the most frustrating parts of the process.

The interesting part isn’t the technology itself.

It’s the feeling of being able to fix something and get it into users’ hands without turning a small change into a full release cycle.

That’s probably why people keep recommending it.

If you’ve used Shorebird in a real app, I’d love to know how your experience was.

A Hackathon Ended. The Idea Didn't: Transforming CADemy into Triax AI for the Next Generation of Makers

JOYSTON — Tue, 02 Jun 2026 16:27:57 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

A few years ago, I participated in a hackathon and built a project called CADemy.

👉 CADemy: https://cademycad.netlify.app/

The idea came from a simple question that kept bothering me:

Why is learning CAD still so expensive?

As engineering students, we're constantly told that skills like 3D design, product development, manufacturing, robotics, and architecture will shape the future. Yet the tools used to learn these skills are often locked behind expensive software licenses that many students simply cannot afford.

For some universities and organizations, this may not be a problem. But for smaller schools, students from rural communities, and underprivileged children, the cost of accessing quality CAD education can be a real barrier.

I kept thinking about something.

A student shouldn't have to wait until college to discover a passion for engineering. Curiosity starts much earlier. A 13-year-old experimenting with design today could become tomorrow's engineer, architect, or inventor.

So during that hackathon, I built CADemy a browser-based platform where anyone could learn CAD concepts through interactive 3D modeling, hands-on challenges, and experimentation.

The project worked. People liked the idea.

But like many hackathon projects, it reached the demo stage and stopped there.

There were features I wanted to build, learning experiences I wanted to improve, and a much bigger vision that simply couldn't fit into a weekend.

When I came across the GitHub Finish-Up-A-Thon Challenge, I knew exactly which project I wanted to revisit.

Instead of starting something new, I decided to finish something I genuinely believed in.

That decision led to Triax AI.

👉 Triax AI: https://triax-ai.netlify.app/

Triax AI is the next evolution of CADemy. It keeps the original mission intact while introducing AI-powered guidance, real-time feedback, interactive tutorials, personalized learning experiences and a significantly improved 3D design environment.

The technology changed.

The interface changed.

Even the name changed.

But the mission remained exactly the same:

To make 3D design education free, fun, and accessible to anyone with curiosity and an internet connection.

Why Jira Is Still the Best Tool for Defect Monitoring and Complex Task Management

JOYSTON — Fri, 29 May 2026 17:21:43 +0000

Modern software teams move fast. Features are released continuously, bugs need immediate attention, and projects often involve multiple teams working together. In this environment, having a proper workflow management system becomes essential.

That’s where Jira by Atlassian stands out.

At first glance, Jira may look like just another issue tracker. But once you start working on real projects, especially large-scale ones, its depth becomes obvious. From defect monitoring to sprint planning and advanced issue tracking through JQL, Jira helps teams stay organized even in highly complex workflows.

Why Jira Works So Well for Defect Monitoring

Jira was originally designed for bug and issue tracking, and that remains one of its strongest areas.

A typical bug workflow in Jira looks something like this:

Open → In Progress → QA Testing → Resolved → Closed

This structure gives teams complete visibility into:

Which bugs are open
Who is working on them
How long issues remain unresolved
Which defects are critical

Jira also allows teams to attach:

Screenshots
Error logs
Stack traces
Videos
Comments

Everything stays centralized inside a single ticket, making communication between QA and developers much smoother.

One of the biggest advantages is traceability. Bugs can be linked directly to:

User stories
Pull requests
Deployments
Releases

This makes debugging and tracking significantly easier in large projects.

Managing Complex Tasks Becomes Easier

Jira is not just for bugs.

It handles complex project structures extremely well through its hierarchy system:

Epic → Story → Task → Sub-task → Bug

This helps teams break large projects into smaller manageable pieces.

For example:

Epic

Launch New Payment System

Stories

Add UPI support
Add card tokenization
Improve checkout UI

Tasks

Create API endpoints
Design database schema
Build frontend integration

This structure keeps technical work aligned with business goals.

Agile Boards Make Collaboration Better

Jira provides both:

Scrum boards
Kanban boards

Scrum boards are useful for sprint-based development with features like:

Sprint planning
Story points
Burndown charts
Velocity tracking

Kanban boards are excellent for continuous workflows and DevOps teams.

The visual nature of Jira boards makes project tracking much easier for both technical and non-technical stakeholders.

Basic Search vs JQL

One of Jira’s most underrated features is its search system.

Basic Search

Basic Search uses filters and dropdowns.

You can quickly search by:

Project
Status
Assignee
Priority
Issue type

It’s beginner-friendly and perfect for non-technical users.

JQL (Jira Query Language)

JQL is where Jira becomes incredibly powerful.

Example:

project = "Ecommerce"
AND issuetype = Bug
AND priority IN (Critical, Blocker)
AND status != Done

This instantly filters critical unresolved bugs from a specific project.

JQL supports:

AND / OR conditions
Date filters
Dynamic user queries
Custom fields
Advanced reporting

For QA engineers and project managers, learning JQL can save a huge amount of time.

My Experience Using Jira

When I first used Jira, I honestly thought it was just another ticketing tool.

But after working on real projects, I realized how effective it is for:

Tracking defects properly
Managing complex workflows
Organizing agile sprints
Improving team visibility

The biggest upgrade for me was learning JQL. Basic Search helped initially, but JQL completely changed how efficiently I could track issues and generate reports.

Final Thoughts

Jira remains one of the best platforms for:

Defect monitoring
Agile project management
Sprint planning
Workflow automation
Complex task coordination

Its combination of flexibility, visibility, and scalability is what makes it so widely used across software teams.

If you’re new to Jira, start with the basics — but definitely spend time learning JQL.

That’s where the real power of Jira begins.

Google AI Studio Finally Feels Like a Real Developer Tool After I/O 2026

JOYSTON — Sun, 24 May 2026 12:34:19 +0000

This is a submission for the Google I/O Writing Challenge

Google I/O 2026 had the usual flood of AI announcements: faster models, smarter agents, multimodal demos, benchmark claims.

But the most important shift wasn’t any single model upgrade.

It was the realization that Google is finally trying to reduce workflow fragmentation for developers instead of just improving prompt quality.

That distinction matters more than most keynote demos admit.

For the past year, my workflow has looked something like this:

ideas in one tab
prompts in another
code in VS Code
deployment somewhere else
documentation scattered across notes and chats
context constantly leaking between tools

So after I/O, I decided to test something practical:

Could Google AI Studio actually support the way developers work after the first prompt?

Not as a showcase.
Not as a five-minute prototype.
As a real workflow surface.

I Stopped Testing Prompts and Started Testing Workflow

To pressure-test the experience, I built a lightweight “release assistant” for my own projects.

The goal was intentionally boring:

convert rough feature notes into structured release plans
generate release notes
identify deployment risks
export markdown summaries
create a small shareable preview

The interesting part wasn’t the app itself.

It was whether AI Studio could reduce the constant context-switching that normally happens between planning, implementation, documentation, and deployment.

My core prompt looked like this:

You are a senior release engineer.

Generate:
- implementation checklist
- release summary
- deployment risks
- rollback concerns
- unresolved questions

If information is unclear, explicitly mark ambiguity.
Do not invent missing details.

That final line ended up being the most important instruction in the entire workflow.

Because the moment you move from “generate ideas” to “generate operational output,” hallucinations stop being funny and start becoming expensive.

The Real Upgrade Wasn’t Better Code Generation

The biggest surprise during testing wasn’t the quality of generated code.

It was the reduction in workflow friction.

Google AI Studio finally feels less like a prompt playground and more like an operational layer between intent and execution.

That’s a subtle but important shift.

Most AI tools today are optimized for producing impressive first drafts. Very few are optimized for preserving context across multiple stages of development.

This is where AI Studio started feeling different after I/O 2026.

The combination of:

Gemini workflows
Cloud Run deployment paths
Workspace connectivity
structured prototyping
multimodal interaction

makes the experience feel much closer to a real developer environment instead of a disconnected experimentation surface.

And honestly, that’s where I think the industry is heading.

The future probably doesn’t belong to the AI tool that writes the most code.

It belongs to the one that loses the least context.

The Most Dangerous Output Was the Most Convincing One

The first release plan the model generated looked excellent.

Clean structure.
Clear priorities.
Confident recommendations.

There was just one problem:
it invented a rollback dependency that didn’t exist.

That moment completely changed how I evaluated the workflow.

Because the output didn’t look broken.
It looked professional.

And that’s the real risk with modern AI tooling.

Bad outputs are easy to catch.
Polished inaccuracies are not.

Once I shifted the workflow toward structured JSON generation first and narrative summaries second, reliability improved significantly.

Instead of asking for prose immediately, I forced the model into deterministic structure first:

{
  "release_title": "Mobile Search Improvements",
  "tasks": [
    "Add debounce handling",
    "Update pagination logic",
    "Improve empty-state logging"
  ],
  "risks": [
    "Ranking changes require QA verification"
  ]
}

That one adjustment made the system noticeably more trustworthy.

It reinforced something I’ve started noticing across AI-assisted development:

Models are often better planners and parsers than autonomous engineers.

AI Still Breaks in Quiet, Expensive Ways

Even after the improvements announced at I/O, the limitations are still very real.

Hallucinations remain dangerous in:

deployment planning
infrastructure logic
API assumptions
dependency management

And debugging AI-generated code is still slower than people publicly admit.

The first draft is usually decent.

The second iteration — where edge cases, integration issues, state management, and production constraints appear — is where human judgment becomes essential again.

Context management also remains fragile.

If your instructions are ambiguous, the model fills gaps with confidence instead of clarification.

That creates a new category of engineering problem:
systems that fail convincingly.

Which is why I think the conversation around AI development is starting to shift away from prompt engineering and toward workflow engineering.

The hard problem is no longer generating code.

The hard problem is maintaining context integrity across an entire development lifecycle.

Google Finally Seems Focused on the Middle Layer of Development

That’s what made Google I/O 2026 interesting to me.

Not the demos.
Not the benchmark charts.
Not the “AI changes everything” narrative.

It was the fact that Google finally seems focused on the messy middle layer between idea and implementation — the part where developers spend most of their time.

Planning.
Refining.
Structuring.
Debugging.
Rewriting.
Deploying.
Remembering what they were doing two hours ago.

That’s where productivity is actually lost.

And reducing that friction compounds fast, especially for:

solo developers
indie hackers
startups
technical creators
small engineering teams

Saving a few minutes on code generation is helpful.

Reducing dozens of context switches every day changes how people build software entirely.

After rebuilding part of my workflow around Google AI Studio, I came away with a surprisingly balanced conclusion:

I still don’t trust AI agents to independently ship production systems.

But I increasingly trust them to structure the path between intent and execution.

And for the first time, Google AI Studio feels like it understands that distinction too.

Building PromptForge AI: Smarter, Lighter, More Sustainable Marketing

JOYSTON — Sat, 02 May 2026 13:09:22 +0000

Modern marketing often creates unnecessary digital waste—duplicate assets, oversized files, and excessive bandwidth usage. Every extra megabyte transferred consumes energy, and at scale, that environmental impact becomes significant.

I built PromptForge AI to tackle this challenge.

PromptForge transforms a simple campaign idea into a complete marketing kit with AI-generated visuals, copy, and multi-platform assets. But instead of generating and storing dozens of separate files, it creates one master asset and uses Cloudinary to dynamically transform, optimize, and deliver every required format.

This dramatically reduces storage waste, lowers bandwidth consumption, improves performance, and minimizes digital carbon emissions. By reusing a single source asset across an entire campaign, PromptForge eliminates redundant file creation and unnecessary compute.

To make sustainability measurable, PromptForge includes a Green Score, a Green Impact Dashboard, a Carbon Budget Tracker, and an Asset Reuse Tracker, helping users understand the real environmental impact of their digital content.

PromptForge shows that great marketing can also be mindful marketing.

Create once. Optimize everywhere. Deliver sustainably.

Screenshot

How MindsDB Is Becoming the Data Brain for AI Agents in 2026

JOYSTON — Tue, 28 Apr 2026 13:59:49 +0000

AI agents are getting smarter. But intelligence alone is not enough.

The real challenge in building production-ready AI systems is not choosing the best model—it is connecting that model to your data, tools, and workflows in a reliable way. That is exactly where MindsDB is making a huge impact.

With its latest 2026 updates, MindsDB is evolving from an AI query layer into a full-fledged federated data and context engine for AI applications and autonomous agents.

If you are building AI products, this shift matters a lot.

The Problem with Today's AI Stack

Most AI applications still rely on a fragmented workflow:

Pull data from multiple databases and SaaS tools
Clean and transform that data
Send it to an LLM
Parse unstructured responses
Push results back into business systems

It works but it is often slow, brittle, and difficult to scale.

Every additional integration introduces more complexity. Every custom pipeline adds maintenance overhead. And every manual handoff creates opportunities for failure.

This is where MindsDB changes the game.

MindsDB's New Direction: A Federated Context Layer for AI

MindsDB is now positioning itself as the infrastructure layer that sits between your data and your AI systems.

Instead of moving data to the model, MindsDB brings AI directly to the data.

That means you can:

Query distributed data sources using SQL
Connect AI agents directly to live business data
Generate structured outputs
Write results back into operational systems
Maintain governance and observability throughout the workflow

This architecture aligns closely with the growing importance of the Model Context Protocol (MCP), which aims to standardize how AI systems interact with external tools and data.

MindsDB is essentially building the practical implementation of that vision.

(mindsdb.com)

What's New in MindsDB in 2026?

1. More Powerful AI Agents

One of the biggest upgrades is the migration from LangChain to a Pydantic-based agent framework.

Why does this matter?

Faster execution
More predictable behavior
Better reliability in production
Cleaner abstractions for developers

The best part? Existing workflows remain compatible. You can continue using familiar commands like CREATE AGENT without rewriting your applications.

This is a significant step toward making AI agents more stable and enterprise ready.

(mindsdb.com)

2. Stronger Knowledge Bases

Knowledge Bases in MindsDB have received major improvements:

PGVector is now the preferred vector backend
Faster ingestion through batched inserts
Better scalability for large datasets
Improved reliability for semantic search workloads

For teams working with retrieval-augmented generation (RAG), these upgrades translate directly into better performance and lower operational friction.

(mindsdb.com)

3. Expanded Enterprise Integrations

MindsDB now supports even more enterprise systems, including:

Oracle
Amazon Redshift
Databricks
TimescaleDB
MariaDB
HubSpot
Shopify
NetSuite

This expanded connector ecosystem allows organizations to unify structured and unstructured data across their entire stack.

Instead of building custom connectors, developers can access everything through a single SQL interface.

That is a massive productivity boost.

(mindsdb.com)

Why This Matters for Developers

AI development is shifting from model-centric design to data-centric design.

The winning applications will not necessarily be those using the most advanced model. They will be the ones that:

Access the right data at the right time
Maintain context across workflows
Produce reliable, structured outputs
Integrate seamlessly into existing systems

MindsDB helps developers focus on building intelligent experiences instead of stitching together infrastructure.

It acts as the missing middleware layer between enterprise data and modern AI.

A Practical Use Case

Imagine building an AI sales assistant.

Without MindsDB, you would need to manually connect:

CRM data from HubSpot
Order data from Shopify
Customer records from PostgreSQL
LLM APIs for reasoning
Custom pipelines for orchestration

With MindsDB, the workflow becomes much simpler:

Query all customer data in one place
Pass that context to an AI agent
Generate recommendations or summaries
Write results back to your CRM automatically

That is not just more efficient it is fundamentally more scalable.

The Bigger Picture: AI Infrastructure Is Maturing

In 2025, the focus was on experimenting with AI.

In 2026, the focus is on operationalizing it.

Organizations now need:

Reliability
Governance
Security
Observability
Interoperability

MindsDB is positioning itself at the center of this transition.

Its latest releases show a clear strategy: become the universal context and data layer for AI-native applications.

And that is a very exciting place to be.

Final Thoughts

The future of AI is not just about smarter models.

It is about smarter systems.

Systems that can securely access distributed data, reason over it, and take action in real time.

MindsDB is building exactly that foundation.

If you are working on AI agents, RAG pipelines, conversational analytics, or enterprise AI applications, MindsDB deserves a place in your toolkit.

Because in the era of autonomous AI, data access is no longer a backend concern it is the core of intelligence.

What are your thoughts on federated AI infrastructure?
Are tools like MindsDB the missing layer for scalable AI applications? Let’s discuss in the comments.

Netlify vs Vercel: Why I Prefer Netlify

JOYSTON — Mon, 27 Apr 2026 04:07:55 +0000

When people build websites today, two names come up again and again: Netlify and Vercel. Both are excellent platforms. Both help developers deploy websites quickly. Both make hosting feel almost magical.

But after using both, I personally prefer Netlify.

This is not about saying Vercel is bad. It is a great platform. In fact, Vercel has done an amazing job, especially for modern frontend development. But Netlify offers a more complete and beginner-friendly experience, especially for developers who want flexibility, simplicity, and powerful built-in features.

Think of it like this:

Vercel is like a super-fast sports car.
Netlify is like a reliable SUV with lots of extra features.

Both will get you where you want to go. But one might fit your journey better.

What Are Netlify and Vercel?

Both Netlify and Vercel let you:

Host websites
Deploy directly from GitHub
Get automatic updates when you push code
Use custom domains
Add serverless functions
Scale easily

In simple words, they help you put your website on the internet without needing to manage servers.

Where Vercel Shines

Before comparing, it's only fair to mention Vercel's strengths.

Excellent performance
Best-in-class support for Next.js
Smooth developer experience
Fast global delivery
Clean and polished interface

If you are building heavily with Next.js, Vercel is often the natural choice.

Why I Prefer Netlify

1. More Framework Freedom

Vercel feels deeply connected to Next.js, which makes sense because Vercel created it.

Netlify, on the other hand, feels more open. It works beautifully with almost any framework:

React
Vue
Angular
Svelte
Astro
Eleventy
Plain HTML, CSS, and JavaScript

It does not feel tied to one ecosystem. That freedom is refreshing.

2. Better Built-In Features

Netlify includes many powerful tools right out of the box:

Forms handling
Identity and authentication
Split testing
Edge functions
Redirects and rewrites
Analytics
Visual editing tools

With Vercel, some of these features require third-party services or additional setup.

Netlify gives you more in one place.

3. Easier for Beginners

If you are just starting out, Netlify feels incredibly welcoming.

Its dashboard is simple, clear, and easy to understand. Setting up forms, redirects, or deployments is straightforward. You don't need to dig through lots of documentation just to get started.

It feels like a platform built to help you succeed from day one.

4. Stronger for Static Sites

Netlify was built with static sites in mind, and it shows.

If you are creating:

Blogs
Portfolios
Documentation sites
Marketing websites
Landing pages

Netlify is often the perfect fit.

It is fast, reliable, and packed with useful features for these kinds of projects.

5. Better All-in-One Experience

With Netlify, you often need fewer external tools.

For example:

Forms? Built in.
User login? Built in.
Deployment previews? Built in.
Site management tools? Built in.

This saves time, reduces complexity, and keeps everything in one place.

A Simple Comparison

Feature	Netlify	Vercel
Framework flexibility	Excellent	Excellent, but Next.js-focused
Built-in forms	Yes	No
Authentication tools	Yes	Limited
Static site features	Excellent	Very good
Next.js optimization	Good	Best
Beginner-friendly	Excellent	Very good

When to Choose Netlify

Netlify is a great choice if you:

Build across multiple frameworks
Want built-in tools
Prefer simplicity
Create static or content-driven websites
Want an all-in-one platform

When to Choose Vercel

Vercel is a great choice if you:

Primarily use Next.js
Need advanced Next.js features
Want highly optimized React workflows
Focus on dynamic web applications

Final Thoughts

Netlify and Vercel are both outstanding platforms. There is no wrong choice.

But for me, Netlify stands out because it feels more complete, flexible, and beginner-friendly. It offers powerful features without making things complicated.

Vercel is fantastic, especially for Next.js developers. But Netlify feels like a platform designed for everyone.

And sometimes, that matters more.

If you want a hosting platform that is simple, powerful, and works well across many types of projects, Netlify is hard to beat.

What has your experience been? Are you Team Netlify, Team Vercel, or somewhere in between?

VirtuLab: A Browser-Based Lab Built to Close the Practical Learning Gap

JOYSTON — Sun, 01 Mar 2026 15:24:12 +0000

This is a submission for the DEV Weekend Challenge: Community

I built VirtuLab for students who struggle not because they lack ability, but because they lack access.

In many colleges, especially underprivileged institutions and rural campuses, physics and electrical labs are limited by shared equipment, outdated apparatus, and tight time slots. Students often get one short session to complete an experiment. If a circuit is wired incorrectly or a setup fails, there is rarely time to restart.

For underprivileged students, the gap is wider. There is no personal lab kit at home. No private coaching. No extra practice outside scheduled hours. Practical exams then become exercises in memorizing steps instead of understanding systems.

VirtuLab was built to give them something most never truly get: repetition without restriction.

What I Built

VirtuLab is a browser-based virtual physics and electrical laboratory that simulates experimentation as a dynamic system, not a fixed animation.

It contains three major environments:

3D Motion and Optics Lab

Students can experiment with pendulums, springs, lenses, and Newtonian motion. Parameters like mass, length, angle, and force can be adjusted in real time, with measurements updating instantly.

2D Circuit Builder

A drag-and-drop circuit workspace where students connect batteries, resistors, LEDs, and other components using precise wire drawing. Circuits behave based on real topology, not visual shortcuts.

Astronomy Lab

A fully interactive celestial mechanics environment including:

Solar System simulation to explore planetary orbits and gravitational interactions
N-body gravity simulation where users can observe multi-body gravitational dynamics
Orbital mechanics experiments to study satellite trajectories and escape velocities
Tidal force visualization to understand gravitational gradients and Roche limits

Students can modify mass, distance, and velocity to observe how orbital paths evolve. This makes gravitational equations observable instead of abstract.

Each environment includes real-time measurement feedback and built-in conceptual explanations to bridge simulation behavior with theory.

Authentication is handled through Appwrite, allowing students to securely access and continue experiments.

What Makes It Different

VirtuLab treats simulations as computational systems, not animations.

In the Circuit Builder, every wire connection is translated into a graph-based internal model. Current and voltage are calculated from actual network topology. If a student leaves a circuit incomplete, it fails realistically.

In the Motion Lab, oscillation periods and forces are recalculated dynamically as parameters change. Nothing is pre-rendered.

In the Astronomy Lab, gravitational interactions are computed continuously. When a student increases planetary mass or modifies initial velocity, orbital paths shift according to gravitational equations, not scripted motion.

Students are not watching outcomes. They are shaping them.

For students with limited lab exposure, this builds intuition instead of dependency on memorized procedures.

Demo

Live Demo:
https://virtulab.appwrite.network/

GitHub Repository:
https://github.com/joyston602-rgb/Virtulab

Example scenario:

A student logs in and opens the Circuit Builder.
They place a battery, resistor, and LED.
They connect terminals carefully.

If the circuit is valid, the LED responds immediately based on calculated current.
If they misconnect a wire, nothing happens.

They adjust resistance. Brightness changes in real time.
They disconnect a node. The system recalculates instantly.

In the Astronomy Lab, they increase a planet’s mass and watch orbital paths tighten due to stronger gravitational pull. They increase initial velocity and observe escape trajectories form.

Cause and effect becomes visible.

Screenshots

Why This Matters

Educational inequality is not only about access to books. It is about access to experimentation.

Students from underprivileged backgrounds often work harder with fewer opportunities to practice. VirtuLab gives them a digital lab bench that does not close after one hour.

Designing a Reliable Contract Intelligence System with Gemini

JOYSTON — Sun, 01 Mar 2026 13:32:49 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

The turning point in this project was not infrastructure. It was deciding whether a language model should sit directly in a production decision path without guardrails.

I built a document intelligence system for contract review. It ingests PDFs, extracts clause-level risk signals, and surfaces them for small businesses that cannot afford outside counsel for routine vendor agreements. The constraint was reliability. If a liability cap was hallucinated or an auto-renewal was missed, the output would not just be inaccurate. It would be harmful.

The architecture has three layers.

A PDF extraction pipeline segments contracts into clauses using heading detection and semantic boundary shifts instead of page splits.

A Gemini layer classifies each clause against a fixed risk taxonomy and generates a plain-language summary with a risk tier.

A React frontend groups clauses by risk tier rather than document order, aligning with how users actually review exposure.

Each clause moves through classify, summarize, score, and validate stages. Prompts are minimal and schema-constrained. Using gemini-1.5-pro with structured JSON output, every response is validated against a Zod schema before entering application state. Failures are flagged for manual review. Nothing degrades silently.

Gemini’s strength here is compression. Dense legal language becomes concise summaries that reflect practical implications. Iterating on the taxonomy exposed overlapping categories early, allowing me to reduce twelve risk types to six in days instead of weeks.

The friction appeared in nested clauses. Parent clauses with modifying sub-clauses produced summaries that were technically correct but incomplete. A liability cap without its exception clause is misleading. The solution was architectural: recursively unnest clauses, inject parent references into context, and reconstruct structure in code. That reduced summarization drift significantly.

Cost was another constraint. A forty-page contract could trigger over thirty model calls. An embedding similarity filter now pre-classifies low-risk template clauses, reducing calls by roughly thirty-five percent without hurting recall.

The real shift was conceptual. I stopped treating Gemini as an assistant and started treating it as a probabilistic component with defined failure modes. Structured outputs, validation boundaries, explicit failure states, and clear separation between language understanding and business logic now define the system.

Next, I am building multi-document comparison to detect deviations across similar vendor agreements. Before release, I am running recall evaluation against a manually annotated dataset. The system works, but without measurable precision and recall under edge cases, it does not belong in decision-critical workflows.

This project changed how I integrate language models. They are not conversational layers on top of applications. They are bounded components inside systems designed for validation, uncertainty, and measurable reliability.

Supabase Has More Depth Than Most People Use

JOYSTON — Wed, 25 Feb 2026 14:45:19 +0000

Most developers use Supabase for the obvious things: tables, authentication and storage. It works well for that. But what often goes unnoticed is how much depth sits underneath.

Because everything is built on Postgres, Supabase isn’t just a backend wrapper it’s a programmable database platform. Features like Row Level Security can move authorization logic directly into the database, reducing the need for repetitive backend checks. When designed properly, your data layer becomes responsible for enforcing access rules.

Database functions exposed through RPC are another underused capability. Instead of building separate APIs for complex operations, you can run logic inside Postgres itself. This keeps operations atomic and simplifies architecture.

Realtime subscriptions tied directly to database changes also feel more integrated than many expect. They allow reactive systems without managing separate infrastructure.

The more you design around the database-first model, the more Supabase reveals its strength. Many teams only use a fraction of what’s available, even though the deeper capabilities are already built in.

Triax AI: A Free, Lightweight 3D CAD Platform Bringing Engineering Education to Underserved Students

JOYSTON — Sat, 14 Feb 2026 06:05:30 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

Triax AI - A completely free, lightweight 3D design education platform that brings professional CAD learning to underprivileged students and aspiring engineers worldwide through AI-powered guidance.

The Problem

Professional CAD software costs thousands of dollars annually. Engineering students from underprivileged backgrounds face impossible barriers: expensive licenses, high-end hardware requirements, and zero interactive guidance. Even existing 3D web applications are notoriously heavy - they lag, crash and are unusable on the basic computers that underprivileged students have access to. They're locked out of careers in design, manufacturing, and engineering before they even start.

The Solution & Core Challenge

Triax AI runs entirely in the browser - no downloads, no installations, no cost. But here's the real innovation: making a full-featured 3D CAD platform lightweight enough for basic hardware.

3D websites are inherently heavy. Real-time rendering, complex geometries, and interactive controls typically require powerful GPUs and significant RAM. The main technical challenge was building a professional-grade 3D modeling environment that runs smoothly on the 4GB RAM laptops and integrated graphics that underprivileged students actually have access to.

Through aggressive optimization - efficient geometry management, smart rendering strategies and minimal bundle sizes - Triax AI delivers real-time 3D modeling with AI-powered mentorship on hardware that can't even run traditional CAD software. It's what expensive CAD courses charge thousands for, but accessible to anyone with a basic computer and internet connection.

Key Features:

Zero Barriers: Completely free, browser-based, works on low-spec devices
AI Mentor: Real-time chatbot that guides students through CAD concepts like a personal tutor
Smart Challenges: Progressive learning system that adapts to each student's pace
Instant Feedback: Automated assessment that validates designs and explains improvements
Professional Tools: Move, rotate, scale, boolean etc.. operations
Dual Modes: Structured tutorials for beginners, playground for creative exploration

The Impact

This isn't just another learning app - it's a pathway to economic mobility. Triax AI gives underprivileged students the same quality CAD education that privileged students pay thousands for. A student in a rural school with a basic laptop now has the same learning opportunity as someone with access to expensive software and private tutoring.

By making 3D design education free, lightweight and AI-enhanced, Triax AI opens doors to engineering careers for students who would otherwise never get the chance.

Demo

Deployed link : https://triax-ai.netlify.app/
Demo Video link : https://www.youtube.com/watch?v=bLIuMA0I_X8

Screenshots

My Experience with GitHub Copilot CLI

The biggest challenge in building Triax AI wasn't adding features - it was making a 3D web application lightweight enough for underprivileged students with basic hardware. 3D websites are notoriously resource-heavy, and GitHub Copilot CLI was absolutely critical in solving this.

1. The Performance Optimization Challenge
3D rendering typically requires powerful GPUs and significant RAM. My target users have 4GB RAM laptops with integrated graphics. Every optimization mattered:

gh copilot suggest "optimize three.js for low memory usage" generated geometry instancing patterns that reduced memory footprint by 60%
Helped implement object pooling to prevent garbage collection spikes that cause stuttering
Suggested efficient LOD (Level of Detail) systems - complex shapes simplify when zoomed out
Generated code for lazy-loading geometries only when needed, keeping initial bundle under 200KB

Without Copilot CLI, I would have spent weeks researching Three.js performance patterns. Instead, I got production-ready optimization code in minutes, letting me iterate rapidly on what actually worked on low-end hardware.

2. Lightweight Rendering Strategies
Traditional 3D apps render everything every frame. On basic hardware, this kills performance:

gh copilot suggest "selective rendering for three.js scene" gave me smart render-on-demand patterns
Helped implement frustum culling to skip rendering objects outside the camera view
Generated efficient raycasting for object selection without performance overhead
Suggested WebGL state management to minimize GPU state changes

Copilot CLI understood the nuances of WebGL optimization - something that would have required deep expertise or days of trial-and-error.

3. Bundle Size Optimization
Every kilobyte matters when students have slow internet. Copilot CLI helped me keep the app lightweight:

Suggested tree-shaking strategies for Three.js (it's a massive library)
Generated dynamic import patterns for features like boolean operations (loaded only when used)
Helped implement efficient state management without heavy frameworks
Suggested compression strategies for 3D assets

The result: a full-featured 3D CAD platform that loads faster than most blog websites.

4. Building the AI Chatbot for Unreliable Networks
Underprivileged students often have unstable internet. The AI mentor needed to work reliably:

gh copilot explain helped me understand streaming response patterns that handle network interruptions
Generated robust retry logic with exponential backoff
Suggested local caching strategies for common CAD questions
Helped implement optimistic UI updates so the app feels responsive even with latency

5. Challenge Assessment System
The automated grading needed to be computationally efficient:

Copilot CLI generated spatial algorithms that run in O(n log n) instead of O(n²)
Suggested efficient bounding box checks before expensive geometry comparisons
Helped implement tolerance-based validation that's both accurate and fast
Generated scoring logic that provides detailed feedback without performance cost

The Real Impact
GitHub Copilot CLI didn't just accelerate development - it made the entire project possible. As a solo developer, I couldn't have achieved this level of performance optimization without it. The CLI gave me access to expert-level knowledge in:

WebGL and Three.js optimization
Memory management for JavaScript applications
Efficient algorithms for 3D spatial queries
Network resilience patterns for unreliable connections

Every suggestion was production-ready, followed best practices, and actually worked on the low-end hardware I was targeting. I could ask "how do I make this faster for 4GB RAM?" and get concrete, implementable solutions.

The natural language interface meant I could stay focused on the mission making CAD education accessible rather than getting lost in documentation. It felt like pair programming with a performance optimization expert who understood both the technical constraints and the social impact goal.

Most importantly: Copilot CLI helped me ship a lightweight, professional grade 3D platform that underprivileged students can actually use. That's not just faster development that's the difference between an idea and real impact.

DEV Community: JOYSTON

Frame-Chaining AI Video: Building a 60-Second Film with GMI Cloud

1. Understanding the Duration Constraint

2. Prompt Engineering: Control the Camera Before the Scene

The single-movement principle

Keep the visual identity consistent

Negative prompts are model-specific

3. Frame Chaining: Maintaining Continuity Between Clips

Extracting the frame with FFmpeg

Uploading the frame to GMI Cloud

Generating the next clip

The ratio configuration issue

What frame chaining actually guarantees

4. Stitching the Film with FFmpeg

When the clips need different processing

Creating a cinematic 2.39:1 presentation

5. Re-Rendering One Bad Shot Instead of the Entire Film

Prompting for accurate text

6. Practical Issues I Encountered

Keep generation parameters in the expected structure

An MCP timeout doesn't necessarily mean generation failed

Check which credits apply to each model

Verify your FFmpeg version

Verify audio instead of trusting the response

Separate language-model usage from media-generation costs

7. Cost Breakdown

8. Scaling the Pipeline Beyond 60 Seconds

Choose boundary frames deliberately

Preserve intermediate frames and generation metadata

Parallelize independent generations

Make every segment independently replaceable

9. Visual Verification Before Delivery

Conclusion

I Tried Shorebird and Finally Understood Why Flutter Developers Keep Talking About It

The problem isn’t writing code — it’s shipping it

So what exactly is Shorebird?

The part I found interesting

Example

Things it doesn’t magically solve

Where I think this makes the most sense

Final thoughts

A Hackathon Ended. The Idea Didn't: Transforming CADemy into Triax AI for the Next Generation of Makers

What I Built

Why Jira Is Still the Best Tool for Defect Monitoring and Complex Task Management

Why Jira Works So Well for Defect Monitoring

Managing Complex Tasks Becomes Easier

Epic

Stories

Tasks

Agile Boards Make Collaboration Better

Basic Search vs JQL

Basic Search

JQL (Jira Query Language)

My Experience Using Jira

Final Thoughts

Google AI Studio Finally Feels Like a Real Developer Tool After I/O 2026

I Stopped Testing Prompts and Started Testing Workflow

The Real Upgrade Wasn’t Better Code Generation

The Most Dangerous Output Was the Most Convincing One

AI Still Breaks in Quiet, Expensive Ways

Google Finally Seems Focused on the Middle Layer of Development

Building PromptForge AI: Smarter, Lighter, More Sustainable Marketing

Screenshot

How MindsDB Is Becoming the Data Brain for AI Agents in 2026

The Problem with Today's AI Stack

MindsDB's New Direction: A Federated Context Layer for AI

What's New in MindsDB in 2026?

1. More Powerful AI Agents

2. Stronger Knowledge Bases

3. Expanded Enterprise Integrations

Why This Matters for Developers

A Practical Use Case

The Bigger Picture: AI Infrastructure Is Maturing

Final Thoughts

Netlify vs Vercel: Why I Prefer Netlify

What Are Netlify and Vercel?

Where Vercel Shines

Why I Prefer Netlify

1. More Framework Freedom

2. Better Built-In Features

The `ratio` configuration issue