DEV Community: MD. Zariful Huq

How AST Made AI-Generated Functions Actually Reliable

MD. Zariful Huq — Mon, 16 Mar 2026 20:27:11 +0000

When I stopped asking the AI to write code and started asking it to describe logic, everything changed — security, predictability, even multi-language support.

I needed AI to generate small, dynamic pieces of logic inside a running system. Nothing exotic — simple calculations, input validations, conditional rules, data transformations. The kind of thing you'd normally write a quick function for, except the rules kept changing and I wanted users to define them without deploying new code.

The obvious approach was to let the model generate a function and execute it. And at first, it worked:

function calculateTotal(price, quantity) {
  return price * quantity;
}

Clean. Correct. Exactly what was needed. So I kept going. And that's when the cracks started to show.

Sometimes the syntax was slightly wrong. Sometimes two runs of the same prompt produced wildly different implementations. Sometimes the model referenced globals it assumed would exist. And occasionally — the part that should make you pause — it reached for eval, fetch, or fs.

Once you're executing AI-generated code inside a running system, you're trusting the model not to do anything dangerous. The model has no idea what your system looks like. It pattern-matches on codebases it trained on. That's not a foundation you want to build on.

I didn't actually want the AI to generate code. I wanted it to generate logic structure. That distinction turned out to be everything.

What AST actually is

AST stands for Abstract Syntax Tree — a structured, tree-shaped representation of a program's logic. Instead of treating code as text, it breaks every operation down into nodes with explicit relationships.

Take a simple function:

function sum(a, b) {
  return a + b;
}

Internally, that's not a string. It's a tree:

FunctionDeclaration
  ├── name: "sum"
  ├── params: ["a", "b"]
  └── body
        └── ReturnStatement
              └── BinaryExpression
                    ├── operator: "+"
                    ├── left:  Identifier("a")
                    └── right: Identifier("b")

Every modern language toolchain works this way. Compilers, linters, formatters, refactoring tools, security scanners — they all convert source text into an AST as early as possible, because structure is vastly easier to reason about than text.

Security scanners walk the tree looking for dangerous patterns. Type checkers resolve variables through scope chains. Formatters rewrite the tree and emit clean code regardless of the original's whitespace.

The question I eventually asked myself: if every serious tool does this for human-written code, why was I letting AI-generated code stay as raw text?

The problem with raw AI-generated code

When a model generates a function, it's producing text. That text has to be parsed, validated, and executed before you know if it's correct — and by then, it's already running in your process.

Here's the kind of thing that can happen:

// The model isn't being malicious — it's pattern-matching
// on "reading config" from its training data
const fs = require('fs');
const config = JSON.parse(fs.readFileSync('/etc/secrets.json'));

function calculate(price) {
  return price * config.taxRate;
}

Looks like a reasonable calculation. But if your system runs it, you've just done a file system read inside what was supposed to be simple business logic. Multiply this across hundreds of dynamically generated functions, and the attack surface becomes enormous.

And that's before accounting for the consistency problem. Ask the same model to generate equivalent logic twice and you'll often get structurally different code — different variable names, different control flow, sometimes different behavior in edge cases. There's no stable contract.

Letting the model generate AST instead

The shift is conceptually simple: instead of generating code, the model generates a data structure that describes what the code should do. Your system then compiles that structure into actual executable code — under complete control, with full validation before anything runs.

The same price * quantity logic that used to be a function now looks like this:

{
  "type": "BinaryExpression",
  "operator": "*",
  "left":  { "type": "Identifier", "name": "price" },
  "right": { "type": "Identifier", "name": "quantity" }
}

The model is no longer writing code. It's describing the shape of logic. Your system receives that description, validates every node against a schema, checks the tree for disallowed patterns, and only then produces a function — using a code generator that you wrote and fully understand.

The architecture that held up

After a few iterations, the pipeline stabilized into something clean:

User request (natural language)
        ↓
LLM generates AST (structured JSON)
        ↓
Schema validation          ← reject malformed trees
        ↓
Security checks            ← node allowlist, depth limits
        ↓
Code generator             ← controlled compilation
        ↓
Executable function

The critical insight: the model is never, at any point, producing something that runs directly. There are two independent checkpoints between model output and execution — and the code that runs is always generated by your system, not the AI.

Why security becomes easy

Once logic is a tree, enforcing security constraints becomes a tree traversal problem. You define what's allowed; everything else is rejected before compilation even begins.

Allowed node types:

BinaryExpression
IfStatement
LogicalExpression
ReturnStatement
CallNode (pre-approved built-ins only)
Identifier, Literal, ConditionalExpression

Blocked node types:

FunctionDeclaration
ImportDeclaration
CallExpression with eval
MemberExpression accessing fs, process, global
WhileStatement (unbounded loops)
NewExpression, AwaitExpression, ThrowStatement

You can also enforce structural constraints that would be nearly impossible to check on raw code: maximum tree depth, maximum node count, an explicit allowlist of which identifiers a function may reference. If a generated AST tries to use a variable that wasn't passed in as an argument, it fails validation before touching the runtime.

Reusable nodes: the real power move

Once you have an AST-based pipeline, a natural next step is exposing pre-built nodes that the model can reference but never reimplement. Think of them as a safe standard library — each node has a vetted internal implementation, and the model only decides how they're composed.

Your system might expose built-in nodes like:

CalculateDiscount
ValidateEmail
NormalizeCurrency
CheckInventory

Instead of generating the discount logic from scratch, the model produces:

{
  "type": "CallNode",
  "node": "CalculateDiscount",
  "inputs": {
    "price": "price",
    "discount": "discountRate"
  }
}

The model isn't writing the discount calculation. It's declaring that the calculation should happen and specifying the wiring. This has a few compounding benefits:

Security — the model can't inject unsafe logic because implementations are controlled by your system
Consistency — the same operation behaves identically across every generated function that uses it
Simpler reasoning — the model only needs to decide which nodes to use and how to connect them, not how to implement each one

It starts to look a lot like how real software is built with libraries. The AST is just the graph that describes how the pieces connect.

Language independence as a bonus

AST has no language. It's a description of logic, not a JavaScript function or a Rust closure or a Python method. That means the same AI-generated tree can be compiled into different targets just by swapping the code generator.

Same AST → JavaScript:

function applyRule(price, quantity) {
  if (quantity > 10) {
    return price * quantity * 0.9;
  }
  return price * quantity;
}

Same AST → Rust:

fn apply_rule(price: f64, quantity: u32) -> f64 {
    if quantity > 10 {
        price * quantity as f64 * 0.9
    } else {
        price * quantity as f64
    }
}

In my case, this wasn't the primary motivation — but once it came for free, it opened up possibilities I hadn't planned for. The AI generates the logic once; the system decides where it runs.

What this resembles, on reflection

Compilers cracked this problem decades ago. Source code as text is just a convenient input format for humans. The moment a compiler gets hold of it, the text is gone — converted to an AST, analyzed, optimized, and compiled into something entirely different. Nobody ships the text to production.

Programs shouldn't remain as text for long. They should become structured representations as early as possible. AI-generated logic is no different — the sooner it becomes a tree you can inspect, the sooner you can trust it.

What surprised me most about this architecture wasn't the security improvement, though that was significant. It was the predictability. Once the model was generating AST instead of code, the outputs became remarkably stable. The same logical requirement produced structurally equivalent trees. Edge cases that used to produce bizarre JavaScript now produced schema errors that were easy to catch and re-prompt for.

The model turned out to be quite good at describing logic structure. It was the job of emitting valid, safe, consistent code that it was bad at — and that was always going to be the system's job anyway.

The shift from code generation to structure generation didn't require a new model, a new framework, or any AI-specific tooling. It just required treating AI output the same way compilers have always treated source code: as a starting point, not a final form.

Built a Beginner-Friendly Course on How LLMs Work — For Myself

MD. Zariful Huq — Mon, 19 May 2025 16:24:02 +0000

I’ve always wanted to understand how Large Language Models (LLMs) actually work — not just use them, but really learn what’s going on under the hood.

So, I built a beginner-friendly course to teach myself the fundamentals — from how LLMs process language, to tokenization, attention, training data, and even how to build a small-scale model from scratch.

The cool part?
The entire course was generated by AI, using free resources from across the internet. 😲

It’s live now on Open Course — feel free to check it out:
🔗 The course

In my next post, I’ll dive into how the AI-generated course feature works.
But for now, I’d love your feedback — does the course help you learn LLMs more easily?

LLM #AI #MachineLearning #OpenCourse #DeepLearning #AItools #SelfLearning #OpenSource #TechLearning

250+ Next.js UI Components from Top Libraries – All in One Free Collection

MD. Zariful Huq — Fri, 25 Apr 2025 19:24:49 +0000

As a frontend developer, finding the right UI components for your Next.js project can be time-consuming. What if you could access 250+ handpicked components from the best libraries—all in one place?

I’ve created a free collection on Open Course (a platform for sharing free learning resources) that brings together the most stunning, functional, and modern UI components from libraries like:

⚡ Aceternity UI (Cutting-edge animations)
🌈 Cuicui (Beautifully designed elements)
🖥️ Shadcn UI (Highly customizable components)
✨ Magic UI (Delightful micro-interactions)
� UI Layout (Responsive layouts)
� Cult UI (Unique design systems)
🏰 Eldora UI (Elegant templates)
🌀 Animata (Motion-rich elements)
🎨 Origin UI (Minimalist & clean)

Whether you're building a SaaS, portfolio, or e-commerce site, this collection will save you hours of searching and give you instant inspiration.

Why This Collection?

✅ One-Stop Solution – No more jumping between 10+ websites.

✅ Free & Open – All components are sourced from freely available content.

✅ Curated for Next.js – Optimized for modern React development.

✅ Design & Code Examples – See previews and implementation snippets.

Who Is This For?

Frontend devs looking for quick UI references
Startups wanting to prototype faster
Designers seeking inspiration for component-based layouts
Students learning modern web development

How to Access the Collection?

Visit the Open Course Collection (link) and start exploring! You can clone, remix, or use these components in your projects—no paywall.

Final Thoughts

Instead of reinventing the wheel, leverage the best UI work from top libraries. This collection is a massive time-saver, and I’ll keep updating it with new components.

What’s your favorite UI library? Let me know in the comments!

CTA:

🔗 Explore the Collection Now | 🚀 Follow for More Web Dev Resources

Techs I Will Be Side Learning in 2024

MD. Zariful Huq — Sat, 30 Dec 2023 19:23:31 +0000

Introduction

In 2024, the pursuit of knowledge enters a new phase amid rapid technological advancements. Embracing side learning is no longer just a personal choice but a strategic necessity. 🚀 This blog explores four key domains shaping our tech landscape: Spatial Computing, Artificial Intelligence (AI), High-Performing Backend Development, and Next-Gen Computing (including Edge and Quantum Computing). Each section demystifies these technologies and highlights exciting career opportunities. 🌐 Join us on a journey of exploration and empowerment into the transformative side learning trends of 2024. 🌟

Spatial computing

Season 6 Vr GIF by Warner Archive - Find & Share on GIPHY

Thousands of Films and TV Series Direct from the Studio's Vault

giphy.com

Spatial computing refers to a computing environment that takes into account the physical space around us and enables interactions with digital information in a spatial context. It involves the integration of digital and physical worlds, allowing users to interact with digital content as if it were part of the physical environment. It's the foundation that makes Extended Reality experiences possible. 🌐

Extended Reality is the umbrella term for all the immersive technologies that blend the physical and digital worlds, including:

Augmented Reality (AR):
Definition: Augmented Reality (AR) integrates digital content into the real world, enhancing user experiences by overlaying virtual elements onto the physical environment.
Benefits: Improves learning, aids in efficient task performance, and enhances user engagement across diverse sectors such as education, training, gaming, marketing, and remote assistance.
Examples: Navigation apps displaying directions on live camera views, Pokemon Go merging virtual characters with real-world locations, and IKEA Place enabling users to visualize furniture in their homes using AR. 📲

Virtual Reality (VR):
Definition: Virtual Reality (VR) constructs a fully immersive digital environment, transporting users into artificial realities where they can explore simulated worlds or engage in activities with a heightened sense of presence.
Benefits: Facilitates realistic training simulations, enhances gaming experiences, enables virtual travel, and finds applications in fields such as healthcare, education, and architecture for visualization and design.
Examples: Immersive gaming scenarios where users feel part of the action, virtual tours of distant locations or historical sites, and medical simulations for surgical training in a controlled, risk-free environment. 🕹️

Mixed Reality (MR):
Definition: Mixed Reality (MR) seamlessly merges the physical and virtual realms, enabling users to interact with both simultaneously. It combines aspects of both augmented and virtual reality, creating immersive experiences that respond to and interact with the real world.
Benefits: Facilitates enhanced visualization and interaction, particularly in fields like healthcare, education, and manufacturing. Offers unique applications, such as collaborative design, training simulations, and real-time data overlay.
Examples: A surgeon using MR to visualize and interact with a patient's internal organs during surgery, collaborative design sessions where virtual objects are manipulated in real space, and educational experiences where virtual elements integrate with the physical environment for interactive learning. 👩‍⚕️🏭

Career Opportunities:

AR/VR Game Developer: Skillcrush 🎮
AR/VR Content Creator: YouTube Video 🎥
AR/VR Healthcare Specialist: Hurix 💉
AR/VR Designer: Toptal ✨
AR/VR Marketing Specialist: AdRoll 📈

Trend in 2024:

Advanced Hardware and Devices
Integration of AI and Machine Learning
5G Integration
Revolutionizing Retail and Shopping
AR in Smart Glasses
Social VR Experiences. 🚀

Artificial Intelligence

Artificial Intelligence Ai GIF by GIPHY News - Find & Share on GIPHY

Discover & share this GIPHY News GIF with everyone you know. GIPHY is how you search, share, discover, and create GIFs.

giphy.com

2023 isn't just another year – it's the year AI explodes onto the scene, reshaping industries, fueling creativity, and demanding your attention. But where do you start? Buckle up, because these 4 AI trends are your golden ticket to a future brimming with exciting possibilities: 🚀

Generative AI:
Definition: Generative AI empowers creative expression by leveraging artificial intelligence algorithms to produce diverse and unique outputs, ranging from images, videos, and music to code. It involves training models to understand patterns and generate novel content based on learned information.
Benefits: Unleashes creativity, automated content creation, and explores new frontiers in artistic expression. Enables the generation of content that may not be conceivable through traditional methods, fostering innovation in various creative domains.
Examples: Creating visually stunning art through algorithms like deep dream, generating music compositions with AI-driven tools like AIVA, and using generative models to produce unique pieces of code or design elements. 🎨🤖

Explainable AI (XAI):
Definition: Explainable AI (XAI) focuses on developing artificial intelligence systems that can be transparently understood and interpreted by humans. It aims to demystify the decision-making processes of complex AI models, allowing users to comprehend and trust the outcomes generated.
Benefits: Enhances user trust by providing insights into AI decision-making, mitigates ethical concerns related to biased or unexplainable outcomes, and facilitates collaboration between humans and AI as partners in problem-solving.
Examples: Visualizing feature importance in a machine learning model, creating interpretable models that highlight decision factors, and developing tools that offer plain-language explanations for AI-driven predictions, fostering a deeper understanding of AI outputs. 🧐🤝

Generative Adversarial Networks (GANs):
Definition: GANs are a dynamic duo of AI, with a generator and discriminator in an adversarial dance. This rivalry pushes the generator to produce hyper-realistic content, from images to entire simulated worlds.
Benefits: Unleashes creativity, perfects content generation, and elevates the realism of AI-created outputs across various applications.
Examples: Crafting lifelike portraits, generating realistic scenes for games, and enhancing synthetic datasets for machine learning through GAN-based augmentation. 🤖🎭

AI SaaS + LLM:
Scenario: Imagine this: You're a small business owner with a brilliant idea for a customer service chatbot. You don't have the resources to build a complex AI system from scratch, but you know the power of language to connect with customers. This is where the AI SaaS + LLM (GPT, LLAMA etc) tag team comes in.
Benefits: Cost-effective, language-proficient chatbot, rapid deployment, guided innovation by LangChain.
Example: Deploying a customer service chatbot swiftly understanding and responding to queries, thanks to AI SaaS, LLMs, and LangChain. 🤖💬

Career Opportunities:

Content Creation using AI: Fiverr Guide 🖼️
Debugging and Troubleshooting AI Systems: LinkedIn Article 🔍
Image and Video Editing using AI: YouTube Video 🎥
Developing and Delivering AI-powered SaaS Solutions: Decktopus Blog 💻
Building Custom AI Solutions for Businesses: Merge Rocks Blog 🏢
Building and Maintaining LLM Infrastructure: CDO Magazine 🌐

Trend in 2024:

AI for Sustainability
AI-powered Cybersecurity
AI-driven Personalization
Quantum Computing and AI
AI Governance and Regulation. 🌿🔐🎯⚛️📜

High performing, scalable Backend

Seth Macfarlane Search GIF by Fox TV - Find & Share on GIPHY

Discover & share this FOX TV GIF with everyone you know. GIPHY is how you search, share, discover, and create GIFs.

giphy.com

As of now, crafting a robust and high-performance backend requires a strategic embrace of cutting-edge technologies, notably gRPC and a Rust-based backend.
Learning the dynamics of gRPC and Rust in 2024 offers a gateway to a modern technology stack, providing a versatile toolkit to build scalable, efficient, and secure backend systems. 🚀

gRPC:
Definition: Communication framework known for streamlined data exchange via Protocol Buffers, high-performance HTTP/2, versatility across languages, and bidirectional streaming support.
Benefits:

Efficiency: Protocol Buffers enhance data serialization for efficient communication. 🔄
Performance: Utilizes HTTP/2 for exceptional speed and reduced latency. ⚡
Versatility: Supports various programming languages for flexibility. 🌐
Bidirectional Streaming: Facilitates simultaneous client-server communication, enhancing real-time interaction. 🔄📡 Example: Employing gRPC in microservices for fast communication, utilizing Protocol Buffers and bidirectional streaming for efficient data exchange. 🛠️

Rust:
Definition: Rust is a memory-safe programming language that prioritizes performance, safety, and concurrency. It stands out for its focus on preventing memory-related errors and providing strong support for concurrent programming.
Benefits:

Memory Safety: Prevents common memory errors, enhancing code robustness. 🧠
Concurrency Support: Facilitates safe concurrent programming, reducing race conditions. 🏎️
Native Code Compilation: Compiles to native code for optimal performance on target hardware. 💻
Developer Productivity: Modern features enhance productivity by minimizing bugs and errors. 🚀
Flourishing Ecosystem: Thriving community provides diverse libraries and tools. 🌱 Example: Developers use Rust for high-performance systems like web servers, ensuring efficiency and security in concurrent environments. 🌐🔒

Career Opportunities:

Web Development: Reddit Discussion 🌐
Blockchain Development: LogRocket Blog ⛓️
Microservices Architecture: Medium Article 🚀

Trend in 2024:

Growing Open Source Ecosystem
Microservices Architecture Staple
Integration with AI and Machine Learning. 🌐🏗️🤖

Next Gen Computing

Coding Looney Tunes GIF by Looney Tunes World of Mayhem - Find & Share on GIPHY

Discover & share this Looney Tunes World of Mayhem GIF with everyone you know. GIPHY is how you search, share, discover, and create GIFs.

giphy.com

Learning about Next Gen Computing, including edge computing and quantum computing, can offer numerous benefits and opportunities in 2024 and beyond. Let's start with brief definitions of each: 🌐🚀

Edge Computing:
Definition: Edge computing brings processing closer to the source of data, rather than relying on centralized cloud servers. Think of it as mini data centers located at the edge of a network, closer to devices and users.
Benefits: Faster response times, reduced latency, improved bandwidth efficiency, better security and privacy for sensitive data, and localized decision-making based on real-time data.
Examples: Processing sensor data from self-driving cars, analyzing video footage from security cameras, or running AI models on smart devices like wearables. 🚗📹💡

Quantum Computing:
Definition: Quantum computers harness the principles of quantum mechanics to perform calculations that are impossible for even the most powerful classical computers. They leverage qubits, which can be 0, 1, or both at the same time (unlike classical bits that are either 0 or 1).
Benefits: Solving complex problems in fields like drug discovery, materials science, financial modeling, and cryptography, potentially leading to revolutionary breakthroughs.
Examples: Simulating molecules to design new drugs, optimizing logistics and supply chains, or breaking current encryption methods. 🧪💼🔐

Career Opportunities:
The rapid advancements in edge and quantum computing are opening up a plethora of exciting career opportunities across various sectors. Here's a glimpse into some of the promising areas: 🌐

Edge AI Engineer: Microsoft Learning Path 👩‍💻
Edge Network Architect: Juniper Documentation 🌐
Big Data Analyst: Simplilearn Article 📊
Quantum Algorithm Developer: Salary Explorer 🎛️
Quantum Software Engineer: ACM Magazines 💻

Trend in 2024:

AI and Machine Learning Advancements
Quantum cryptography
5G Technology Expansion
Blockchain and Decentralized Finance (DeFi)
Health Tech and Telemedicine
Robotics and Automation. 🚀🔒📶🔗🏥🤖

Conclusion

In the tapestry of tech evolution, 2024 unfolds as a canvas colored by Spatial Computing, AI, High-Performing Backend Development, and Next Gen Computing. Concluding our exploration, the importance of these trends emerges. They aren't just novelties but gateways to a future where innovation knows no bounds. Skills in navigating Spatial Computing, leveraging AI, mastering high-performance backends, and embracing cutting-edge computing pave the way for a future where our collective potential is limitless. Let 2024 be the year we plant the seeds of knowledge that bloom into the tech marvels of tomorrow. The journey continues, and the possibilities are boundless. 🌐🤖🚀💡