DEV Community: Jehadur Rahman (Emran)

Beyond Code: Why Soft Skills Are the True Multiplier for Developers

Jehadur Rahman (Emran) — Thu, 16 Jul 2026 23:22:22 +0000

In the rapidly evolving landscape of software engineering, we often obsess over the latest frameworks, cloud architectures, and language features. We spend our weekends learning Rust, Kubernetes, or the next big AI integration. Yet, when we look at the trajectory of successful careers, one truth remains consistent: technical prowess is merely the baseline. The true differentiator, the multiplier that takes a developer from "good" to "great," is the mastery of soft skills.

The Myth of the Lone Wolf

The caricature of the antisocial programmer hacking away in a dark room is a relic of the past. Modern software development is a team sport. Whether you are working in an Agile scrum, a startup, or a massive enterprise, your ability to interact with others is as critical as your ability to write clean, efficient code.

1. Communication as a Technical Skill

Communication is not just about "being nice." It is about precision. When you explain a complex technical limitation to a non-technical product manager, you are translating abstract concepts into business value. This is a technical skill. If you cannot articulate why a feature takes two weeks to build, you lose the trust of your stakeholders.

Consider the difference in how we document our code. Writing readable code is an act of empathy for your future self and your teammates.

// Bad
const d = 86400000; // milliseconds in a day

// Good
const MS_PER_DAY = 86400000;

The second example isn't just "clean code"; it is effective communication.

2. Empathy: The User-Centric Mindset

Technical debt is often a result of ignoring the human element. When we ignore soft skills, we build software that works, but it doesn't solve problems. Empathy allows us to step into the user's shoes. It asks, "Does this feature actually help the person using it, or does it just add bloat?"

3. Conflict Resolution and Collaboration

Technical debates are inevitable. How you handle disagreement defines your leadership potential. The best developers don't fight to be "right"; they fight to find the best solution for the company. This requires active listening, patience, and the ability to detach your ego from your pull request.

Final Thoughts

Soft skills are not "fluffy." They are the scaffolding that supports your technical expertise. As you progress in your career, prioritize your ability to lead, listen, and communicate just as much as you prioritize your ability to code. Your code can change the system, but your soft skills will change the world around you.

Prompt Engineering is Dead, System Design Matters More

Jehadur Rahman (Emran) — Thu, 16 Jul 2026 23:19:14 +0000

The era of obsession with the "perfect prompt" is coming to a close.

For the last year, many of us have spent countless hours iterating on system instructions, trying to nudge LLMs into better performance. We treated prompts like magic spells. But in production-grade AI, the prompt is just one variable. The real engineering—and the real differentiator—is the system design that surrounds the model.

The "Harness" is the Ceiling

As industry experts often note, the model sets the floor, but the harness sets the ceiling.

What is this harness? It is the infrastructure of your agent. It is the scaffolding that makes an LLM useful in a real-world environment. If you focus only on the prompt, you are building on sand.

Memory: How do you store, retrieve, and summarize long-term knowledge?
Tool Calling: How does the agent safely interact with APIs, files, and databases?
Durable Execution: If your process crashes, can your agent recover its state?
Orchestration: How do you manage multi-agent handoffs and complex sub-tasks?

The AI Agent Stack

If you are still only looking at the prompt, you are missing the architectural layers that make agents production-ready. The typical agent stack is far deeper than a single API call:

Agent Runtime: The reasoning loop (think, tool call, observe, reflect).
Model Layer: The engine powering reasoning.
Tool Layer: The "hands" of the agent.
Memory Layer: Short-term working memory and long-term retrieval.
Observability & Safety: Debugging, evaluation, and cost-control guardrails.

Why System Design Wins

When you treat your AI agent as a software system rather than a text-completion task, your priorities shift. You stop asking, "Why won't the model follow these instructions?" and start asking, "How can I make the state transitions more reliable?"

Robustness comes from designing for failure, not from perfectly crafted system instructions. Consider a simple, modular agent loop implementation that prioritizes error recovery:

def run_agent_loop(task, context):
    memory = initialize_memory(context)
    while not task.is_complete():
        # Step 1: Reason and pick tool
        action = model.generate(memory, task)

        # Step 2: Safe execution with error handling
        result = execute_with_timeout(action)

        # Step 3: Update state and memory
        memory.update(action, result)
        if result.error: 
            handle_recovery(result)

    return memory.final_answer()

The Future is Infrastructure

Prompt engineering will always be a part of the workflow, but it is no longer the bottleneck. The real challenges lie in managing context, ensuring reliable tool execution, and building systems that can self-correct when things go wrong.

If you want to build AI that actually works, stop chasing the next model release and start investing in your harness. Engineering for resilience, scalability, and observability is what separates a toy chatbot from a production-grade agent.

What are you building? Are you focusing on the harness or the prompt? Let me know in the comments.

Why Most AI Agents Fail in Production: Bridging the Infrastructure Gap

Jehadur Rahman (Emran) — Thu, 16 Jul 2026 23:19:02 +0000

The landscape of software development is undergoing a tectonic shift. While industry projections suggest that 40% of enterprise applications will run AI agents by the end of 2026, the reality is that many organizations remain stuck in the experimentation phase. The reason for this "agent gap" is rarely about the intelligence of the model itself; rather, it is about the infrastructure surrounding it.

As noted by engineers at the forefront of this shift, the model sets the floor, but the harness sets the ceiling. If you are struggling to move your agents from a local prototype to a reliable production system, you are likely missing one of the four critical pillars: context management, robust tool calling, intelligent memory, and durable execution.

1. The Criticality of Context Management

Retrieval-Augmented Generation (RAG) is often the first step, but it is rarely enough. Whether you are using standard RAG, Graph RAG, or moving toward Agentic RAG—where agents break queries into sub-questions and verify their own retrieved context—the way you manage data is pivotal. Standard RAG is fast and cheap, but it lacks the depth required for complex, multi-step reasoning. For structured knowledge like compliance or legal data, Graph RAG provides superior traversal, whereas Agentic RAG allows for self-correction.

2. Intelligent Tool Calling and Orchestration

An agent that can only "chat" is limited. The transition to a functional agent requires a harness that allows for delegation, triage, and orchestration. Your infrastructure must support a loop where tools, streaming, and model turns fit together seamlessly. You are no longer just building a prompt; you are building an execution environment.

3. Memory Systems: Compaction and Summarization

One of the biggest pitfalls in production agents is the degradation of performance over long conversations due to token limits. To maintain consistency, you must implement memory systems that prioritize summarization and compaction. By keeping long-term context relevant and compressed, your agent can maintain its "personality" and efficacy without overflowing the window.

4. Error Recovery and Durable Execution

Production systems crash. If your agent is a stateless script, a single disconnect can ruin an hour of work. Implementing durable execution—such as using DBOS or Postgres—ensures that sessions survive crashes and network interruptions.

Consider the structure of a basic production-grade loop:

def run_agent_loop(task):
    # Ensure the state is persisted for recovery
    with durable_execution_context():
        while not task.is_complete():
            context = retrieve_relevant_memory(task)
            action = model.generate_action(context)

            if action.is_tool_call():
                # Securely execute tool and update state
                result = execute_sandboxed_tool(action)
                update_memory_with_result(result)
            else:
                finalize_output(action)

Conclusion

The competitive edge in 2026 will not belong to those who merely integrate the latest model, but to those who master harness engineering. By focusing on durable infrastructure, controlled tool execution, and robust memory management, you can finally close the gap between your prototype and a production-grade AI system. For further learning on building these systems, resources like Scott's AI Engineering course offer deep dives into agent orchestration.

Building an Agentic Coding Assistant Without Breaking the Bank

Jehadur Rahman (Emran) — Thu, 16 Jul 2026 23:17:09 +0000

Building an Agentic Coding Assistant Without Breaking the Bank

The landscape of software engineering has shifted as AI agents become integral to developer workflows. However, with increased autonomy comes the challenge of cost management. This guide outlines how to build a robust, production-grade agentic assistant while maintaining efficiency.

The AI Agent Stack

To build effectively, you must understand the four distinct layers of an AI agent:

Agent Runtime: Operates the ReAct loop, allowing the model to reflect on results and plan the next step.
Model Layer: The foundational LLM. Choosing the right model (e.g., opting for cost-effective open-weight models like Kimi K2.7) can significantly impact your budget.
Tool Layer: Provides the "hands" for the agent (APIs, search, code execution).
Memory Layer: Manages short-term working memory, long-term semantic memory, and state storage.

Optimizing for Cost and Performance

Many developers default to complex, multi-agent architectures that introduce unnecessary coordination costs. Here is how to keep your build lean:

1. Start with a Single Agent

Begin with a single reasoning LLM that plans and executes. Only transition to multi-agent architectures when the problem becomes too large for a single agent to coordinate.

2. Context Management

Avoid passing redundant context. Implementing a context maturity model can prevent "token burning" and inconsistent outputs. Utilize memory layers to store transactional states effectively.

3. Loop Implementation

A basic ReAct loop allows for reflection and self-correction, which increases reliability without needing massive, expensive models.

def run_agent_loop(task_description):
    memory = initialize_memory()
    while not task_complete():
        # Reflect and plan
        plan = model.get_next_step(task_description, memory)
        # Execute
        result = tool_executor.run(plan)
        # Update state
        memory.update(result)

Conclusion

The most efficient systems leverage unique data and intelligent retrieval rather than heavy orchestration. By focusing on observability and safety, you can deploy agents that are debuggable, cost-aware, and production-ready. For further learning on advanced workflows, consider resources like the GitHub Education community or specialized https://www.google.com/url?q=https://zenva.acemlna.com/lt.php?x%3D4lZy~GDKJFCd65J_yA~NheSeAqBTutf0w~k1jXE4VqTPD5N7_ky7xuFw232kjdJf0DYxzKpEInSb6I37y_5OYOG-2HQiitH&sa=E&source=workflows courses.

Building NLP Tools for Languages That Big Tech Ignores

Jehadur Rahman (Emran) — Wed, 24 Jun 2026 06:10:34 +0000

In an era where massive Large Language Models (LLMs) dominate headlines, millions of speakers of underrepresented languages remain excluded from the AI revolution. Building NLP tools for these "low-resource" languages isn't just a technical challenge; it is a necessity for democratizing technology.

Understanding the Fundamentals

To build effective tools, we must first understand the building blocks of Natural Language Processing (NLP). NLP is the field of artificial intelligence where computers analyze and derive meaning from human language. Key concepts include:

Stemming and Lemmatization: Stemming reduces words to their root format (e.g., "branching" becomes "branch"), while Lemmatization uses dictionaries to normalize words (e.g., "was" becomes "be").
Parts of Speech (POS) Tagging: The task of labeling each word with its appropriate grammatical part of speech.
Named Entity Recognition (NER): Identifying and classifying entities like names, organizations, or locations.

When dealing with languages ignored by big tech, standardized models often fail because they lack the necessary training data or linguistic nuance. This is where custom development becomes crucial.

The Python Toolkit

Python remains the language of choice for the data science community due to its versatility and mature ecosystem. When starting your project, you will likely rely on powerful packages like:

Gensim: Excellent for analyzing large textual collections and implementing algorithms like word2vec to transform text into vector features.
Scikit-learn: A library essential for tasks like classification, regression, and clustering.
NumPy: For high-level mathematical functions and matrix computations.

Getting Started: A Simple Workflow

Before diving into complex neural networks, focus on the basics of text preprocessing. Vectorization, the process of converting text into numerical representation, is a vital first step. You can implement a simple stemming process to normalize your data using NLTK:

import nltk
from nltk.stem import PorterStemmer

stemmer = PorterStemmer()
words = ["branched", "branching", "branches"]

for word in words:
    print(f"{word} -> {stemmer.stem(word)}")

Thinking Like a Designer

Writing the "right" software requires more than just code; it requires understanding the human interface. Designers of ML systems must anticipate how users will interact with the system. When building for underrepresented languages, consider:

Data Scarcity: You may not have access to massive datasets. Use techniques like transfer learning or unsupervised learning for topic modeling to extract insights from smaller document collections.
Technical Debt: Avoid poor system design that accumulates interest over time. Focus on refactoring code to ensure it remains maintainable and scalable as your project grows.
Community Engagement: Leverage open-source knowledge bases and participate in the community to gather authentic, domain-specific data.

Conclusion

Building tools for ignored languages empowers creators and developers to bridge the digital divide. By utilizing Python's robust libraries and adhering to solid software engineering principles—like test-driven development and refactoring—you can create systems that truly serve diverse linguistic populations. Start small, focus on the essentials, and build a system that reflects the unique nuances of your target language.

The Invisible 99%: Why Low-Resource Languages Need More AI Research

Jehadur Rahman (Emran) — Wed, 24 Jun 2026 06:10:13 +0000

In the current landscape of rapid AI development, large language models (LLMs) like GPT-4 and LLaMA have become standard tools for productivity and information access. However, this technological revolution is built on a foundation of "high-resource" languages—those with abundant digital data, standardized writing systems, and significant online presence. As these models become deeply integrated into societal functions, we face an urgent, often overlooked crisis: the marginalization of low-resource languages.

Understanding the Language Divide

Of the world's over 7,000 living languages, only a tiny fraction are classified as "high-resource". Low-resource languages are those that suffer from a lack of labeled training data, poor data quality, or the absence of standardized orthography. This data scarcity creates a "long-tail distribution" in machine learning, where the majority of global languages remain underserved by modern AI technology.

The technical disparity is exacerbated by the way current AI pipelines are constructed. Most models rely on massive, internet-scraped datasets that favor dominant languages. When developers build for "scale," they often ignore the nuanced, cultural, and linguistic specificities of smaller language communities.

Why This Matters

The consequences of this digital gap extend far beyond mere convenience. We are witnessing several critical impacts:

Socio-Economic Exclusion: Language barriers impede access to essential services like quality education, healthcare, and financial tools. If AI-driven government or commercial interfaces do not function in a user's native language, they effectively cut those populations off from participating in the modern economy.
Safety and Bias Risks: Studies have shown that models like GPT-4 are significantly more likely to produce harmful or unsafe content when prompted in low-resource languages compared to high-resource ones. This occurs because safety fine-tuning and guardrails are overwhelmingly optimized for English, failing to generalize to other linguistic contexts.
Cultural and Intellectual Loss: Language is a repository of human history and cultural identity. When these languages are excluded from AI advancements, the incentive for younger generations to maintain or use them diminishes, threatening their long-term survival.

A Path Forward: Rethinking Development

To bridge this gap, the AI research community must move away from the "bigger is always better" mentality. Addressing the language gap requires dedicated, interdisciplinary collaboration rather than just brute-force data collection.

One promising avenue is the development of specialized, smaller-scale models trained on curated, high-quality datasets rather than massive, noisy web scrapes. Additionally, adopting participatory design approaches—where native speakers are involved in every stage of the AI development cycle—ensures that models are culturally representative and accurate.

For developers interested in exploring this space, evaluating model performance across diverse linguistic tiers is a critical first step. Below is a simplified conceptual example of how researchers might implement a check for data distribution parity in a training pipeline:

def evaluate_language_parity(dataset_metrics):
    # Calculate representation scores for each language
    for language, count in dataset_metrics.items():
        if count < THRESHOLD:
            flag_for_augmentation(language)
            print(f"Priority Alert: {language} is underrepresented.")
    return "Optimization required for long-tail languages."

Conclusion

The inclusion of all languages is essential for the future of global AI. As we continue to advance LLM capabilities, it is our collective responsibility to ensure that this progress does not come at the cost of linguistic diversity. By subsidizing research, supporting data stewardship, and designing methods that "do more with less," we can build a future where AI empowers, rather than excludes, communities around the world.

Conquering Complexity: Building a Robust Bangla Proofreading API

Jehadur Rahman (Emran) — Wed, 24 Jun 2026 05:57:34 +0000

Unlocking Linguistic Precision: The Technical Challenges of Building a Bangla Proofreading API

Creating an automated proofreading tool for the Bangla language is a task that sits at the intersection of complex morphology and computational linguistics. Unlike English, Bangla presents distinct challenges that require custom engineering solutions to ensure accuracy and user satisfaction.

1. The Morphological Hurdle

Bangla is an agglutinative language, where prefixes and suffixes are frequently combined with roots to alter meaning. A simple dictionary lookup will inevitably fail to catch errors in conjugated verbs or complex compound words. Developers must focus on morphological analyzers and stemming algorithms to understand the root structure of words, rather than relying on static word lists.

2. Unicode Normalization

One of the most persistent issues in Bangla NLP is the inconsistency in Unicode character representation, particularly regarding the 'hasant' (্) and various vowel signs. Different keyboards and operating systems may produce visually identical text that is encoded differently, leading to massive indexing errors. A robust API must implement a rigorous normalization layer before any processing occurs.

Consider this simple example of a normalization pipeline:

import unicodedata

def normalize_bangla_text(text):
    # Convert input to normalized Unicode form (NFC)
    return unicodedata.normalize('NFC', text)

3. Data Scarcity and Quality

While languages like English enjoy vast, curated corpora, Bangla lacks the sheer scale of high-quality, annotated datasets for training grammar checkers. Building a deep learning model often requires vast amounts of labeled 'correct vs. incorrect' text. Developers often have to rely on synthetic data generation or limited open-source resources available on platforms like Hugging Face.

4. Contextual Nuance and Ambiguity

Bangla possesses a rich vocabulary where spelling variations—such as 'ওঠো' vs 'উঠো'—can depend heavily on regional dialects or formal versus informal usage. Building an API requires an N-gram or Transformer-based model capable of analyzing sentence structure to flag context-specific errors accurately. The model must be trained not just to spot spelling mistakes, but to understand the semantic intent of the sentence.

Conclusion

Building a Bangla proofreading API is more than just coding; it is about respecting the linguistic architecture of the language. By focusing on morphological analysis and high-quality Unicode normalization, we can bridge the digital divide for Bangla speakers and provide a tool that is both functional and culturally aware.

Algorithmic Logo Design: Building Numerical Integration into the CyArm SVG

Jehadur Rahman (Emran) — Mon, 22 Jun 2026 07:15:52 +0000

When we approach logo design as a form of systemizing, we move beyond the limitations of manual vector tools and embrace the beauty of repeatable, algorithmic truths. Creating the CyArm SVG requires us to bridge the gap between abstract mathematical functions and concrete visual output—a practice reminiscent of Feynman's approach to physics, where internalizing the problem geometry leads to the most elegant solutions.

At its core, building this logo relies on numerical integration. By calculating the path segments of our design through iterative summation, we generate complex, organic shapes that are inherently structured. This process mirrors the emergence of complex patterns from simple feedback loops, where the system dictates the form through self-stabilization.

To implement this, we can use a JavaScript function that iterates through a defined range, calculating coordinates based on a function f(x) and appending them to an SVG path string.

function generateLogoPath(f, start, end, steps) {
  const width = (end - start) / steps;
  let d = M ${start} ${f(start)};
  for (let i = 1; i <= steps; i++) {
    let x = start + (i * width);
    let y = f(x);
    d +=  L ${x} ${y};
  }
  return d;
}

This technique allows for infinite variation. By simply tweaking the underlying mathematical function, we generate a logo that is not only visually striking but also mathematically consistent. It transforms the act of design from a subjective endeavor into a precise, exploratory process of defining systems.

The Art of CSS: Rendering a Chrysanthemum using only HTML and CSS

Jehadur Rahman (Emran) — Mon, 22 Jun 2026 06:27:25 +0000

The Art of CSS: Rendering a Chrysanthemum using only HTML and CSS

CSS art is a fascinating intersection of design and technical precision. By leveraging powerful properties like border-radius, linear-gradient, box-shadow, and transform, you can create intricate illustrations without loading a single external image file. Today, we are exploring the process of rendering a Chrysanthemum—a flower defined by its dense, rhythmic petals—using nothing but pure HTML and CSS.

The Philosophy of CSS Art

When we build with CSS, we are essentially drawing shapes. A flower is simply a collection of layered div elements and pseudo-elements. The secret to rendering a complex, organic shape like a chrysanthemum is breaking it down into basic geometric components: petals, layers, and a central core.

Constructing the Petals

The signature 'rounded teardrop' shape of a chrysanthemum petal can be achieved using border-radius combined with transform: rotate(). By carefully rotating these shapes around a central point, we can mimic the bloom pattern. Check out this snippet for a single petal:

css
.petal {
width: 50px;
height: 100px;
background: linear-gradient(to bottom, #ff0, #f90);
border-radius: 50% 50% 0 0;
position: absolute;
transform: rotate(45deg);
transform-origin: bottom center;
}

Stacking and Layering

To achieve depth, you will want to use z-index and varied opacities. A chrysanthemum has hundreds of petals. To optimize this without cluttering your HTML, use CSS pseudo-elements (::before and ::after) as much as possible. This keeps your DOM tree clean while allowing for complex layering.

For more inspiration on CSS Art, check out the community work at CodePen or CSS-Tricks.

Why Create CSS Art?

Beyond the aesthetic challenge, CSS art is an excellent way to improve your understanding of the CSS box model, positioning, and animations. It forces you to think spatially and creatively about browser rendering.

Go ahead, open your favorite code editor and see if you can manifest a floral masterpiece today!

Implementing Premium Tech Typography in CSS: A shutdownX Case Study

Jehadur Rahman (Emran) — Mon, 22 Jun 2026 06:10:57 +0000

Typography is the backbone of user experience in modern SaaS applications. When we set out to build the interface for https://shutdownx.com, we knew that legibility and a premium "tech-first" aesthetic were non-negotiable. While managing our infrastructure via Supabase and tracking user behavior through Microsoft Clarity, we realized that typography directly influences how users interact with our data-heavy dashboards.

The Challenge of Modern Readability

In a world of high-DPI displays, "premium" doesn't just mean a nice font family—it means responsive, fluid scale. We needed a system that looked as sharp on a mobile device as it did on a wide-screen monitor. Additionally, given that we have been actively monitoring our site performance and indexing status in Google Search Console, we understood that lean CSS was critical for reducing layout shifts and improving core web vitals.

Implementing Fluid Typography

Instead of relying on rigid media queries for font sizing, we implemented fluid typography using the CSS clamp() function. This allows the font size to scale smoothly between a defined minimum and maximum range without triggering layout breakpoints.

css
:root {
  --fluid-min-width: 320px;
  --fluid-max-width: 1440px;
  --fluid-min-size: 16px;
  --fluid-max-size: 20px;
}

body {
  font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
  font-size: clamp(
    var(--fluid-min-size),
    calc(var(--fluid-min-size) + (var(--fluid-max-size) - var(--fluid-min-size)) * ((100vw - var(--fluid-min-width)) / (var(--fluid-max-width) - var(--fluid-min-width)))),
    var(--fluid-max-size)
  );
}

Optimizing for the "Tech" Aesthetic

A premium tech feel often relies on hierarchy and contrast. For our headers, we utilized tabular figures (font-variant-numeric: tabular-nums) to ensure that data displayed in our Supabase-backed tables remained perfectly aligned. This is crucial for financial or metrics-heavy dashboards where visual consistency equals trust.

Performance Considerations

As noted in our recent Search Console reports, indexing issues such as "Page indexed without content" or "Duplicate, Google chose different canonical than user" can be exacerbated by poor site structure. By leveraging modern CSS variables and a system-font-first approach, we reduced our external font requests, contributing to faster FCP (First Contentful Paint) times. This keeps our site lightweight and ensures search engines can parse our content hierarchy efficiently.

Key Takeaways

Use clamp() for fluid typography to eliminate excessive media queries.
Leverage system font stacks to minimize network requests and improve performance.
Use tabular-nums for data-heavy components to maintain professional alignment.
Monitor your CSS impact on site performance using tools like Microsoft Clarity to ensure that your design choices aren't negatively impacting your SEO.

Building for the web requires balancing aesthetics with technical performance. By standardizing our typography, we have not only improved the look of https://shutdownx.com but also laid a stronger, more maintainable foundation for our frontend.

Have you implemented fluid typography in your projects? Let me know your favorite techniques in the comments!

Stop Nesting: How to Optimize Your Data Mapping Performance

Jehadur Rahman (Emran) — Mon, 22 Jun 2026 05:31:45 +0000

Why You Should Stop Using Nested Loops for Data Mapping
Nested loops are a common pitfall in software development. They appear frequently when merging datasets, filtering lists, or finding relationships between two arrays. While they might seem intuitive at first, they often lead to performance bottlenecks as your data grows.

The Problem with Nested Loops
When you nest a loop inside another, you create quadratic time complexity, represented as O(n * m) in Big O Notation. For example, if you have two lists of 1,000 items each, a nested loop will perform 1,000,000 operations.

// The Slow Approach
const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
const orders = [{ userId: 1, item: 'Book' }, { userId: 2, item: 'Pen' }];

const result = users.map(user => {
const userOrder = orders.find(order => order.userId === user.id);
return { ...user, order: userOrder };
});
In this example, for every user, the code scans the entire orders array. If the orders list contains thousands of records, your application will slow down significantly.

The Solution: Lookups and Maps
The most efficient way to solve this is to reduce the time complexity from O(n * m) to O(n). You can achieve this by transforming one of the datasets into a dictionary or a Map structure for constant-time lookup.

// The Fast Approach
const orderMap = new Map(orders.map(order => [order.userId, order]));

const result = users.map(user => ({
...user,
order: orderMap.get(user.id)
}));
By creating the orderMap first, we traverse the orders array exactly once. When we map through the users array, looking up the associated order becomes an O(1) operation.

Why This Matters

Performance: Your application remains responsive even with large datasets.
Scalability: As your product grows, your code is less likely to become a performance bottleneck.
Maintainability: Cleaner, more efficient code is easier to debug and read. By avoiding nested loops in favor of hash maps or specialized lookup structures, you ensure your software scales gracefully. Optimize your data mapping early to build robust and performant applications.

Building an Apple Mail Channel Plugin for OpenClaw

Jehadur Rahman (Emran) — Mon, 22 Jun 2026 03:12:42 +0000

Building an Apple Mail Channel Plugin for OpenClaw

I recently built and published a plugin that integrates Apple Mail with OpenClaw (an AI automation platform), allowing AI agents to monitor and respond to emails with per-thread session isolation.

🎯 The Problem

OpenClaw and Hermes are powerful AI automation platforms, but they lacked native Apple Mail integration on macOS. Users wanted to:

Monitor multiple email accounts
Have AI agents automatically respond to emails
Maintain conversation context across email threads
Keep different email conversations isolated

💡 The Solution

I built @jehadurre/openclaw-apple-mail - a channel plugin that:

Connects to Apple Mail via AppleScript
Creates isolated sessions per email thread
Processes HTML emails intelligently
Supports multi-account configuration
Includes security features like sender allowlists

🛠️ Technical Stack

TypeScript - Type-safe development
AppleScript - Native macOS Mail.app integration
HTML Processing - DOMPurify, jsdom, sanitize-html, marked
Schema Validation - Zod for configuration validation

📦 Key Features

1. Per-Thread Session Isolation

Each email conversation gets its own isolated session, preventing context mixing:

// Each thread gets unique session ID
const sessionId = `apple-mail:${threadId}`;

2. Multi-Account Support

Configure multiple email accounts with independent settings:

{
  "channels": {
    "apple-mail": {
      "accounts": {
        "work": {
          "email": "work@company.com",
          "pollIntervalMs": 15000,
          "archiveOnReply": true
        },
        "personal": {
          "email": "personal@gmail.com",
          "pollIntervalMs": 60000
        }
      }
    }
  }
}

3. Security Features

Sender allowlist per account
HTML sanitization
AppleScript sandboxing

4. Smart HTML Processing

Automatically converts HTML emails to clean markdown:

Table extraction and conversion
Removes tracking pixels
Sanitizes malicious content
Preserves formatting for AI agents

📚 Publishing Journey

I published this plugin to multiple platforms:

1. npm Registry

npm install @jehadurre/openclaw-apple-mail

2. GitHub

Full source code
Issue tracking
Contribution guidelines
MIT License

3. ClawHub

openclaw plugins install @jehadurre/openclaw-apple-mail

4. OpenClaw Skill

Created a comprehensive setup skill:

clawhub install apple-mail-setup

The skill includes:

Installation guide
5 configuration templates
Troubleshooting solutions
Best practices

🎓 Lessons Learned

1. Compiled Output Matters

ClawHub requires compiled JavaScript, not just TypeScript source. I had to:

Get compiled output from production deployment
Include index.js in the package
Update package.json to reference the compiled file

2. Skills Enhance Adoption

Creating a separate "skill" package that teaches users how to set up and use the plugin significantly improves the user experience.

3. Multi-Platform Publishing

Publishing to npm, GitHub, ClawHub, and creating documentation on GitHub Pages maximizes discoverability.

🚀 Usage Example

Here's how users set it up:

Step 1: Install

openclaw plugins install @jehadurre/openclaw-apple-mail
clawhub install apple-mail-setup

Step 2: Configure

Add to openclaw.json:

{
  "channels": {
    "apple-mail": {
      "enabled": true,
      "accounts": {
        "personal": {
          "email": "user@example.com",
          "mailboxAccount": "iCloud",
          "allowFrom": ["*"]
        }
      }
    }
  }
}

Step 3: Start

openclaw start

That's it! OpenClaw now monitors your email and can respond automatically.

📊 Architecture

User Email → Apple Mail.app
              ↓ (AppleScript)
           Plugin Monitor
              ↓
        Session Manager (per-thread isolation)
              ↓
         HTML Processor
              ↓
        OpenClaw/Hermes AI Agent
              ↓
          Response
              ↓ (AppleScript)
        Apple Mail.app → Send Reply

🔐 Security Considerations

Sender Allowlist: Only process emails from trusted senders
HTML Sanitization: Remove malicious content from HTML emails
AppleScript Sandboxing: Limited access to Mail.app APIs
No Credential Storage: Uses existing Apple Mail accounts

🌟 Future Enhancements

Planned features:

[ ] Smart reply suggestions
[ ] Attachment handling
[ ] Email categorization
[ ] Custom email templates
[ ] Integration with other channels

📖 Resources

GitHub: https://github.com/JehadurRE/openclaw-apple-mail
npm: https://www.npmjs.com/package/@jehadurre/openclaw-apple-mail
Documentation: https://openclaw-apple-mail.jehadurre.me
Skill: clawhub install apple-mail-setup

🤝 Contributing

Contributions welcome! Check out the Contributing Guide.

💬 Feedback

Have you used AI automation with email? What features would you like to see? Let me know in the comments!

About Me: I'm Md. Jehadur Rahman (Emran), a developer passionate about AI automation and productivity tools. Find me on GitHub and my website.

License: MIT - Free to use, modify, and redistribute!