How to Use LLMs to Streamline Workflow

I’ve been building and managing data systems at Amazon for the last 8 years. Now that AI is everywhere, the way we work as data engineers is changing fast. Here are 5 real ways I (and many in the industry) use LLMs to work smarter every day as a Senior Data Engineer: 1. Code Review and Refactoring LLMs help break down complex pull requests into simple summaries, making it easier to review changes across big codebases. They can also identify anti-patterns in PySpark, SQL, and Airflow code, helping you catch bugs or risky logic before it lands in prod. If you’re refactoring old code, LLMs can point out where your abstractions are weak or naming is inconsistent, so your codebase stays cleaner as it grows. 2. Debugging Data Pipelines When Spark jobs fail or SQL breaks in production, LLMs help translate ugly error logs into plain English. They can suggest troubleshooting steps or highlight what part of the pipeline to inspect next, helping you zero in on root causes faster. If you’re stuck on a recurring error, LLMs can propose code-level changes or optimizations you might have missed. 3. Documentation and Knowledge Sharing Turning notebooks, scripts, or undocumented DAGs into clear internal docs is much easier with LLMs. They can help structure your explanations, highlight the “why” behind key design choices, and make onboarding or handover notes quick to produce. Keeping platform wikis and technical documentation up to date becomes much less of a chore. 4. Data Modeling and Architecture Decisions When you’re designing schemas, deciding on partitioning, or picking between technologies (like Delta, Iceberg, or Hudi), LLMs can offer quick pros/cons, highlight trade-offs, and provide code samples. If you need to visualize a pipeline or architecture, LLMs can help you draft Mermaid or PlantUML diagrams for clearer communication with stakeholders. 5. Cross-Team Communication When collaborating with PMs, analytics, or infra teams, LLMs help you draft clear, focused updates, whether it’s a Slack message, an email, or a JIRA comment. They’re useful for summarizing complex issues, outlining next steps, or translating technical decisions into language that business partners understand. LLMs won’t replace data engineers, but they’re rapidly raising the bar for what you can deliver each week. Start by picking one recurring pain point in your workflow, then see how an LLM can speed it up. This is the new table stakes for staying sharp as a data engineer.

LLMs are the single fastest way to make yourself indispensable and give your team a 30‑percent productivity lift. Here is the playbook. Build a personal use‑case portfolio Write down every recurring task you handle for clients or leaders: competitive intelligence searches, slide creation, meeting notes, spreadsheet error checks, first‑draft emails. Rank each task by time cost and by the impact of getting it right. Start automating the items that score high on both. Use a five‑part prompt template Role, goal, context, constraints, output format. Example: “You are a procurement analyst. Goal: draft a one‑page cost‑takeout plan. Context: we spend 2.7 million dollars on cloud services across three vendors. Constraint: plain language, one paragraph max. Output: executive‑ready paragraph followed by a five‑row table.” Break big work into a chain of steps Ask first for an outline, then for section drafts, then for a fact‑check. Steering at each checkpoint slashes hallucinations and keeps the job on‑track. Blend the model with your existing tools Paste the draft into Excel and let the model write formulas, then pivot. Drop a JSON answer straight into Power BI. Send the polished paragraph into PowerPoint. The goal is a finished asset, not just a wall of text. Feed the model your secret sauce Provide redacted samples of winning proposals, your slide master, and your company style guide. The model starts producing work that matches your tone and formatting in minutes. Measure the gain and tell the story Track minutes saved per task, revision cycles avoided, and client feedback. Show your manager that a former one‑hour job now takes fifteen minutes and needs one rewrite instead of three. Data beats anecdotes. Teach the team Run a ten‑minute demo in your weekly stand‑up. Share your best prompts in a Teams channel. Encourage colleagues to post successes and blockers. When the whole team levels up, you become known as the catalyst, not the cost‑cutting target. If every person on your team gained back one full day each week, what breakthrough innovation would you finally have the bandwidth to launch? What cost savings could you achieve? What additional market share could you gain?

𝗟𝗟𝗠 𝘃𝘀. 𝗥𝗔𝗚 𝘃𝘀. 𝗙𝗶𝗻𝗲-𝗧𝘂𝗻𝗶𝗻𝗴 𝘃𝘀. 𝗔𝗴𝗲𝗻𝘁 𝘃𝘀. 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗔𝗜 — 𝗪𝗵𝗲𝗻 𝘁𝗼 𝘂𝘀𝗲 𝘄𝗵𝗮𝘁 I keep getting one question from teams building with GenAI: Which approach should we choose? This one-pager visual breaks down the trade-offs. Below is the practical guide I use on real projects. 𝟭) 𝗟𝗟𝗠 What it is: Prompt → model → answer. Use when: General knowledge, ideation, drafting, small utilities. Watch out for: Hallucinations on domain-specific facts; limited to model’s pretraining. 𝟮) 𝗥𝗔𝗚 (𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹-𝗔𝘂𝗴𝗺𝗲𝗻𝘁𝗲𝗱 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻) What it is: Query → retrieve context from a knowledge base → feed context + query to LLM → grounded answer. Model weights don’t change. Use when: You have proprietary docs, policies, catalogs, tickets, or logs that change frequently. Benefits: Lower cost than training, auditable sources, fast updates. Key tips: Good chunking, embeddings, metadata, and re-ranking determine quality more than the LLM choice. 𝟯) 𝗙𝗶𝗻𝗲-𝗧𝘂𝗻𝗶𝗻𝗴 What it is: Train the model on input→output pairs to change its weights (LLM → LLM′). Use when: You need consistent style, domain tone, or task-specific behavior (classification, templated replies, structured outputs). Benefits: Lower prompt complexity, stable behavior, smaller inference tokens. Caveats: Needs clean, labeled data; versioning and evaluation are critical. 𝟰) 𝗔𝗴𝗲𝗻𝘁 What it is: LLM + memory + tools/APIs with a think → act → observe loop. Use when: Tasks require multi-step reasoning, tool use (search, SQL, APIs), or state over time. Examples: Troubleshooting flows, data enrichment, workflow automation. Risks: Loops, tool misuse, latency. Use guardrails, timeouts, and action limits. 𝟱) 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗔𝗜 (𝗠𝘂𝗹𝘁𝗶-𝗔𝗴𝗲𝗻𝘁 𝗦𝘆𝘀𝘁𝗲𝗺𝘀) What it is: Coordinated roles (planner, executor, critic) that plan → act → observe → learn from feedback. Use when: Complex processes with decomposition, review, and collaboration across specialized agents. Examples: Customer ops copilots, multi-step ETL with validation, enterprise workflows spanning multiple systems. Challenges: Orchestration, determinism, monitoring, and cost control. Metrics that matter Grounding: citation hit-rate, answer verifiability (RAG) Quality: task accuracy, pass@k, error rate Efficiency: latency, tokens, cost per resolution Safety: hallucination rate, tool misuse, policy violations Reliability: determinism, replayability, test coverage Design Tips: Start with RAG before touching fine-tuning; data beats weights early on. Keep prompts short; push knowledge to the retriever or the dataset. Add evaluation harnesses from day one (gold sets, unit tests for prompts/tools). Log everything: context windows, actions, failures, and human overrides. Treat agents like software: versioning, guardrails, circuit breakers, and audits.

Few Lessons from Deploying and Using LLMs in Production Deploying LLMs can feel like hiring a hyperactive genius intern—they dazzle users while potentially draining your API budget. Here are some insights I’ve gathered: 1. “Cheap” is a Lie You Tell Yourself: Cloud costs per call may seem low, but the overall expense of an LLM-based system can skyrocket. Fixes: - Cache repetitive queries: Users ask the same thing at least 100x/day - Gatekeep: Use cheap classifiers (BERT) to filter “easy” requests. Let LLMs handle only the complex 10% and your current systems handle the remaining 90%. - Quantize your models: Shrink LLMs to run on cheaper hardware without massive accuracy drops - Asynchronously build your caches — Pre-generate common responses before they’re requested or gracefully fail the first time a query comes and cache for the next time. 2. Guard Against Model Hallucinations: Sometimes, models express answers with such confidence that distinguishing fact from fiction becomes challenging, even for human reviewers. Fixes: - Use RAG - Just a fancy way of saying to provide your model the knowledge it requires in the prompt itself by querying some database based on semantic matches with the query. - Guardrails: Validate outputs using regex or cross-encoders to establish a clear decision boundary between the query and the LLM’s response. 3. The best LLM is often a discriminative model: You don’t always need a full LLM. Consider knowledge distillation: use a large LLM to label your data and then train a smaller, discriminative model that performs similarly at a much lower cost. 4. It's not about the model, it is about the data on which it is trained: A smaller LLM might struggle with specialized domain data—that’s normal. Fine-tune your model on your specific data set by starting with parameter-efficient methods (like LoRA or Adapters) and using synthetic data generation to bootstrap training. 5. Prompts are the new Features: Prompts are the new features in your system. Version them, run A/B tests, and continuously refine using online experiments. Consider bandit algorithms to automatically promote the best-performing variants. What do you think? Have I missed anything? I’d love to hear your “I survived LLM prod” stories in the comments!

I discovered I was designing my AI tools backwards. Here’s an example. This was my newsletter processing chain : reading emails, calling a newsletter processor, extracting companies, & then adding them to the CRM. This involved four different steps, costing $3.69 for every thousand newsletters processed. Before: Newsletter Processing Chain (first image) Then I created a unified newsletter tool which combined everything using the Google Agent Development Kit, Google’s framework for building production grade AI agent tools : (second image) Why is the unified newsletter tool more complicated? It includes multiple actions in a single interface (process, search, extract, validate), implements state management that tracks usage patterns & caches results, has rate limiting built in, & produces structured JSON outputs with metadata instead of plain text. But here’s the counterintuitive part : despite being more complex internally, the unified tool is simpler for the LLM to use because it provides consistent, structured outputs that are easier to parse, even though those outputs are longer. To understand the impact, we ran tests of 30 iterations per test scenario. The results show the impact of the new architecture : (third image) We were able to reduce tokens by 41% (p=0.01, statistically significant), which translated linearly into cost savings. The success rate improved by 8% (p=0.03), & we were able to hit the cache 30% of the time, which is another cost savings. While individual tools produced shorter, “cleaner” responses, they forced the LLM to work harder parsing inconsistent formats. Structured, comprehensive outputs from unified tools enabled more efficient LLM processing, despite being longer. My workflow relied on dozens of specialized Ruby tools for email, research, & task management. Each tool had its own interface, error handling, & output format. By rolling them up into meta tools, the ultimate performance is better, & there’s tremendous cost savings. You can find the complete architecture on GitHub.

How to Use AI to Build Things (Even If You’re Not Technical) — #4 LLMs can write working code, but it becomes far more useful when we reshape it to match how we think as #clinicians. That means refactoring not just for clarity, but to align with our clinical mental models. Take a creatinine clearance calculation. Instead of leaving it as one big block, break it into steps that reflect how we think: - calc_ideal_body_weight() and calc_adjusted_body_weight() - select_weight_to_use() - choose_crcl_formula(sex) - calculate_crcl() — combines all steps into one reusable abstraction Now the code mirrors our clinical workflow making it easier to understand, validate, and explain. There's also a technical bonus too :) - Reusability: use functions across tools - Readability: clearer for you and collaborators who are less technical - Composability: build complex workflows from simple parts If the LLM gives you raw code, ask it to refactor into functions. Then inject your domain knowledge to structure it in a way that makes sense to you. #HealthcareOnLinkedIn #VibeCoding #AI

We know LLMs can substantially improve developer productivity. But the outcomes are not consistent. An extensive research review uncovers specific lessons on how best to use LLMs to amplify developer outcomes. 💡 Leverage LLMs for Improved Productivity. LLMs enable programmers to accomplish tasks faster, with studies reporting up to a 30% reduction in task completion times for routine coding activities. In one study, users completed 20% more tasks using LLM assistance compared to manual coding alone. However, these gains vary based on task complexity and user expertise; for complex tasks, time spent understanding LLM responses can offset productivity improvements. Tailored training can help users maximize these advantages. 🧠 Encourage Prompt Experimentation for Better Outputs. LLMs respond variably to phrasing and context, with studies showing that elaborated prompts led to 50% higher response accuracy compared to single-shot queries. For instance, users who refined prompts by breaking tasks into subtasks achieved superior outputs in 68% of cases. Organizations can build libraries of optimized prompts to standardize and enhance LLM usage across teams. 🔍 Balance LLM Use with Manual Effort. A hybrid approach—blending LLM responses with manual coding—was shown to improve solution quality in 75% of observed cases. For example, users often relied on LLMs to handle repetitive debugging tasks while manually reviewing complex algorithmic code. This strategy not only reduces cognitive load but also helps maintain the accuracy and reliability of final outputs. 📊 Tailor Metrics to Evaluate Human-AI Synergy. Metrics such as task completion rates, error counts, and code review times reveal the tangible impacts of LLMs. Studies found that LLM-assisted teams completed 25% more projects with 40% fewer errors compared to traditional methods. Pre- and post-test evaluations of users' learning showed a 30% improvement in conceptual understanding when LLMs were used effectively, highlighting the need for consistent performance benchmarking. 🚧 Mitigate Risks in LLM Use for Security. LLMs can inadvertently generate insecure code, with 20% of outputs in one study containing vulnerabilities like unchecked user inputs. However, when paired with automated code review tools, error rates dropped by 35%. To reduce risks, developers should combine LLMs with rigorous testing protocols and ensure their prompts explicitly address security considerations. 💡 Rethink Learning with LLMs. While LLMs improved learning outcomes in tasks requiring code comprehension by 32%, they sometimes hindered manual coding skill development, as seen in studies where post-LLM groups performed worse in syntax-based assessments. Educators can mitigate this by integrating LLMs into assignments that focus on problem-solving while requiring manual coding for foundational skills, ensuring balanced learning trajectories. Link to paper in comments.

I replaced 307 lines of agent code with just 4 lines. Graph-based thinking changed everything for my LLM agents. Curious how a 100-line framework can transform your AI workflows? Read on. I've spent years building my own agent framework and teaching graph theory, but discovering PocketFlow made me rethink my approach to LLM-powered programs. Its graph-based abstraction was a game-changer for clarity and modularity. My old AgentBot implementation had a 307-line __call__ method. With PocketFlow, I rebuilt it in about 100 lines, with the core agent graph constructed in just 4 lines. PocketFlow structures LLM programs as graphs, not loops. Each Node is a unit of execution, and Flows connect them, making the logic explicit and visualizable. This shift made my code more maintainable and easier to reason about. In this blogp ost, I share concrete examples: topic extraction, agentic date retrieval, and shell command execution—all orchestrated as graphs. The new approach let me visualize agent architectures and made adding new tools trivial. The biggest lesson? Thinking in graphs, not loops, transforms how you build LLM applications. It brings clarity, modularity, and makes your execution flow explicit. If you're curious about building smarter, more maintainable LLM agents, check out my deep dive and let me know your thoughts! How are you structuring your LLM-powered workflows—loops, graphs, or something else? What challenges have you faced? #ai #llm #agentframeworks #graphtheory #machinelearning

Don't ask an LLM to do your evals. Instead, use it to accelerate them. LLMs can speed up parts of your eval workflow, but they can’t replace human judgment where your expertise is essential. Here are some areas where LLMs can help: 1. First-pass axial coding: After you’ve open coded 30–50 traces yourself, use an LLM to organize your raw failure notes into proposed groupings. This helps you quickly spot patterns, but always review and refine the clusters yourself. Note: If you aren’t familiar with axial and open coding, see this faq: https://lnkd.in/gpgDgjpz 2. Mapping annotations to failure modes: Once you’ve defined failure categories, you can ask an LLM to suggest which categories apply to each new trace (e.g., “Given this annotation: [open_annotation] and these failure modes: [list_of_failure_modes], which apply?”). 3. Suggesting prompt improvements: When you notice recurring problems, have the LLM propose concrete changes to your prompts. Review these suggestions before adopting any changes. 4. Analyzing annotation data: Use LLMs or AI-powered notebooks to find patterns in your labels, such as “reports of lag increase 3x during peak usage hours” or “slow response times are mostly reported from users on mobile devices.” However, you shouldn’t outsource these activities to an LLM: 1. Initial open coding: Always read through the raw traces yourself at the start. This is how you discover new types of failures, understand user pain points, and build intuition about your data. Never skip this or delegate it. 2. Validating failure taxonomies: LLM-generated groupings need your review. For example, an LLM might group both “app crashes after login” and “login takes too long” under a single “login issues” category, even though one is a stability problem and the other is a performance problem. Without your intervention, you’d miss that these issues require different fixes. 3. Ground truth labeling: For any data used for testing/validating LLM-as-Judge evaluators, hand-validate each label. LLMs can make mistakes that lead to unreliable benchmarks. 4. Root cause analysis: LLMs may point out obvious issues, but only human review will catch patterns like errors that occur in specific workflows or edge cases—such as bugs that happen only when users paste data from Excel. Start by examining data manually to understand what’s going wrong. Use LLMs to scale what you’ve learned, not to avoid looking at data. Read this and other eval tips here: https://lnkd.in/gfUWAjR3

One AI coding hack that helped me 15x my development output: using design docs with the LLM.  Whenever I’m starting a more involved task, I have the LLM first fill in the content of a design doc template.  This happens before a single line of code is written.  The motivation is to have the LLM show me it understands the task, create a blueprint for what it needs to do, and work through that plan systematically.. –– As the LLM is filing in the template, we go back-and-forth clarifying its assumptions and implementation details. The LLM is the enthusiastic intern, I’m the manager with the context.  Again no code written yet. –– Then when the doc is filled in to my satisfaction with an enumerated list of every subtask to do, I ask the LLM to complete one task at a time.  I tell it to pause after each subtask is completed for review. It fixes things I don’t like.  Then when it’s done, it moves on to the next subtask.  Do until done. –– Is it vibe coding? Nope.  Does it take a lot more time at the beginning? Yes.  But the outcome: I’ve successfully built complex machine learning pipelines that run in production in 4 hours.  Building a similar system took 60 hours in 2021 (15x speedup).  Hallucinations have gone down. I feel more in control of the development process while still benefitting from the LLM’s raw speed.  None of this would have been possible with a sexy 1-prompt-everything-magically-appears workflow. –– How do you get started using LLMs like this?  @skylar_b_payne has a really thorough design template: https://lnkd.in/ewK_haJN –– You can also use shorter ones. The trick is just to guide the LLM toward understanding the task, providing each of the subtasks, and then completing each subtask methodically. –– Using this approach is how I really unlocked the power of coding LLMs.