Introduction<\/h2>\n\n\n\n
What if you could sketch out an idea for a Python function, and an AI workflow would not only write it \u2014 but also review it, improve it, and suggest enhancements<\/em>? That\u2019s exactly what we\u2019re going to explore in this article.<\/p>\n\n\n\n We\u2019ll walk through how to use LangGraph<\/a>, an open-source tool built on top of LangChain, to create a step-by-step workflow<\/strong> that behaves like a lightweight agent. Now, just to be clear: this isn\u2019t a full agent. It doesn\u2019t reflect, reason over tools, or handle memory across sessions like a long-term autonomous system. Instead, we\u2019re building a structured AI flow<\/em> \u2014 something that mimics agentic behavior by looping through tasks like proposing, reviewing, and revising code based on your input.<\/p>\n\n\n\n We\u2019ll get hands-on by building a Python proof of concept<\/strong>. Using LangChain, LangGraph, and an Ollama-hosted model (yes, all local and open-source friendly), we\u2019ll create a script that takes a natural language prompt \u2014 something like \u201cWrite a Python function to check if a number is prime\u201d<\/em> \u2014 and walks through a self-revision loop to output better, cleaner code.<\/p>\n\n\n\n This is part one of a small series. In a future article, we\u2019ll crank things up and explore how to build a full agent using LangGraph\u2019s more advanced features like stateful memory, tool use, and condition-based decision making.<\/p>\n\n\n\n But let\u2019s not get ahead of ourselves. For now, let\u2019s dive into this self-revising mini-engine and see how LangGraph makes it feel like magic.<\/p>\n\n\n\n In this project, we’re going to build a Python script that acts like a self-improving mini-coder. You\u2019ll give it a natural language prompt \u2014 something like \u201cWrite a function to sort a list without using built-in sort\u201d<\/em> \u2014 and it will go through a smart little loop:<\/p>\n\n\n\n Generate \u2192 Review \u2192 Improve \u2192 Review\u2026 \u2192 Done<\/strong><\/p><\/blockquote>\n\n\n\n At the heart of this loop is an LLM (hosted with Ollama<\/a>) that does all the heavy lifting:<\/p>\n\n\n\n This loop continues for a set number of iterations (to avoid going full Skynet), and then it outputs the final version of the code.<\/p>\n\n\n\n Now, here\u2019s the interesting part: this setup feels like an agent\u2026 but it isn\u2019t technically<\/strong> an agent. Why? Because there\u2019s no long-term memory, no goal prioritization, no dynamic planning. It doesn\u2019t ask itself what tools to use or whether it should Google something. Instead, we\u2019ve defined a workflow<\/strong> \u2014 a fixed structure that loops intelligently, but stays predictable and controllable.<\/p>\n\n\n\n In other words, it\u2019s agentic-like. You get some of the flexibility and autonomy of an agent, but with the clarity and structure of a flowchart. And that\u2019s exactly what LangGraph is great for.<\/p>\n\n\n\n Oh, and just for fun (and for documentation nerds), the script also outputs a Mermaid.js diagram definition<\/strong> of the workflow so you can visualize the full process. It even gives you a simple text-based version right in your terminal \u2014 handy if you\u2019re running this on a server or want to see the logic at a glance.<\/p>\n\n\n\n By the end, you\u2019ll not only have a Python PoC that rewrites its own code \u2014 you\u2019ll also understand how to design AI workflows that feel<\/em> intelligent without going full agent-mode. That next step? We\u2019ll save that for another article.<\/p>\n\n\n\n Before diving into the examples, ensure that your development environment is set up with the necessary tools and dependencies. Here\u2019s what you\u2019ll need:<\/p>\n\n\n\n With these prerequisites in place, you\u2019ll be ready to proceed with the code generation PoC.<\/p>\n\n\n\n Let\u2019s roll up our sleeves and take a look at the code that powers our self-reviewing Python script. (Don\u2019t worry \u2014 you\u2019ll find the full code at the end of this article if you want to explore or run it yourself.)<\/p>\n\n\n\n This script uses LangChain<\/strong>, LangGraph<\/strong>, and an LLM from Ollama<\/strong> (in this case, This is where everything starts. We feed the model a user-provided description (like “check if a word is a palindrome”<\/em>) and ask it to generate a Python snippet \u2014 complete with comments. The input is stored in the This function uses a simple Time to channel our inner code reviewer. In this step, the LLM plays the role of a senior engineer reviewing the code \u2014 but without<\/em> rewriting anything. Instead, it gives textual feedback, highlighting flaws, inconsistencies, or suggestions.<\/p>\n\n\n\n This is key: we\u2019re treating the model as a separate reviewer, not a rewriter (yet). That separation helps keep each stage focused.<\/p>\n\n\n\n Now the script takes the original code and<\/em> the review feedback and asks the LLM to generate a better version. This mirrors how a developer might reflect on code comments and refine their implementation.<\/p>\n\n\n\n We also increment the We don\u2019t want to loop forever (even if that sounds fun). This function checks whether we\u2019ve hit the maximum number of iterations (set by This is where LangGraph shines. Here, we define a directed graph with three main nodes ( With this, we\u2019ve created a loop where the improved code goes back to the review step, and the loop ends when At the bottom of the script, inside the We also generate two types of graph representations:<\/p>\n\n\n\nWhat We\u2019re Building (and Why It\u2019s Kind of Agentic)<\/h2>\n\n\n\n
Prerequisites<\/h2>\n\n\n\n
pipenv<\/code> to set up the required libraries. Execute the following command in your terminal:<\/li><\/ul><\/li><\/ol>\n\n\n\npipenv install langchain langchain-ollama langgraph grandalf<\/code><\/pre>\n\n\n\nBreaking Down the Code: How the Self-Improving Flow Works<\/h2>\n\n\n\n
codellama<\/code>) to build a looped workflow that mimics how a developer might write, review, and improve their own code. Let\u2019s break down the most important parts.<\/p>\n\n\n\nStep 1: Generate the Initial Code<\/h3>\n\n\n\n
def generate_code(state):\n ...<\/code><\/pre>\n\n\n\nstate<\/code> dictionary, and the output gets saved as the code<\/code>.<\/p>\n\n\n\nSystemMessage<\/code> and HumanMessage<\/code> combo to set context and send the actual prompt to the LLM. If anything goes wrong, it gracefully logs an error comment in the code.<\/p>\n\n\n\nStep 2: Review the Code<\/h3>\n\n\n\n
def review_code(state):\n ...<\/code><\/pre>\n\n\n\nStep 3: Improve the Code<\/h3>\n\n\n\n
def improve_code(state):\n ...<\/code><\/pre>\n\n\n\niteration<\/code> count here so we know how many review-improve cycles we’ve gone through.<\/p>\n\n\n\nStep 4: Decide If We Keep Looping<\/h3>\n\n\n\n
def should_continue(state):\n ...<\/code><\/pre>\n\n\n\nMAX_ITERATIONS<\/code>). If we\u2019re not done, it returns 'continue'<\/code>, sending the flow back to another review cycle. Otherwise, we exit with 'done'<\/code>.<\/p>\n\n\n\nBuilding the Workflow with LangGraph<\/h3>\n\n\n\n
def create_workflow():\n ...<\/code><\/pre>\n\n\n\ngenerate<\/code>, review<\/code>, improve<\/code>) and the edges between them. LangGraph makes it easy to map out this flow as a graph, including conditional edges like:<\/p>\n\n\n\nworkflow.add_conditional_edges('improve', should_continue, {'continue': 'review', 'done': graph.END})<\/code><\/pre>\n\n\n\nshould_continue()<\/code> says it\u2019s time.<\/p>\n\n\n\nRunning the Workflow (and Visualizing It!)<\/h3>\n\n\n\n
__main__<\/code> block, we initialize the model and run the workflow:<\/p>\n\n\n\nstate_intent = {\n 'description': 'A Python function to check if a word is a palindrome or not.',\n 'iteration': 1\n}<\/code><\/pre>\n\n\n\n
![\"\"](\"https:\/\/temperies.com\/wp-content\/uploads\/2025\/04\/workflow.png\")
<\/figure>\n\n\n\n