DEV Community: Jubril Bilal

I Built an AI Agent From Scratch. Here's What Nobody Tells You.

Jubril Bilal — Thu, 06 Aug 2026 16:27:17 +0000

The theory is clean. The reality is messier. And honestly more interesting.

Everyone's talking about AI agents. Few people are showing you what it actually looks like to build one. So here's my honest account — what worked, what broke, and what surprised me.

A note before you start copying code: LangChain's agent APIs move fast, and some of what I used when I built this is now deprecated. I've flagged that inline below rather than pretending it didn't happen, that's kind of the point of this post.

What actually makes something an "agent"?

Before building anything, it's worth being precise about what we're building. An AI agent needs four things:

An LLM as the brain — the reasoning engine
Memory — context that persists across steps
Tools — the ability to actually take actions
A loop — plan → act → observe → repeat

Miss any one of the four and you don't have an agent. You have a fancy prompt.

The stack I used

Python 3.11
LangChain (agent framework)
OpenAI GPT-4o (the brain)
Tavily (web search tool)
Python REPL (code execution tool)

Building a research agent, step by step

Step 1 — Install dependencies

pip install langchain langchain-openai tavily-python python-dotenv

Step 2 — Set up your tools

from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_experimental.tools import PythonREPLTool

tools = [
    TavilySearchResults(max_results=3),
    PythonREPLTool()
]

Step 3 — Initialize the agent

This is the part that's changed the most since I first built this. Here's what I originally used:

# what I originally used — this pattern is now deprecated
from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent
from langchain import hub

llm = ChatOpenAI(model="gpt-4o", temperature=0)

# ReAct = Reason + Act, the classic agent loop pattern
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm, tools, prompt)

Heads up: create_react_agent and AgentExecutor have since been deprecated in favor of create_agent from langchain.agents. The underlying concept — model, tools, and a loop wrapping them — hasn't changed. The constructor has. If you're starting fresh, check docs.langchain.com for the current signature before you build on top of this; LangChain's API surface has genuinely moved twice since I wrote this walkthrough.

Step 4 — Add the execution loop

from langchain.agents import AgentExecutor

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,          # see the agent's thinking
    max_iterations=10,
    handle_parsing_errors=True
)

Step 5 — Give it a goal

result = agent_executor.invoke({
    "input": """
    Research the current state of AI agents in enterprise software.
    Find 3 specific companies using them, what they're doing,
    and the results. Then write a structured summary.
    """
})

print(result["output"])

What actually happened when I ran this

Here's the agent's internal monologue, straight from verbose=True:

Thought: I need to search for information about AI agents 
in enterprise software.

Action: tavily_search
Action Input: "AI agents enterprise software companies"

Observation: [search results...]

Thought: I found information about Klarna and Salesforce. 
I need a third, more specific example.

Action: tavily_search
Action Input: "enterprise AI agent deployment results case study"

[continues for 6 more steps...]

Final Answer: [structured, sourced summary]

Watching this play out in real time is genuinely the best way to understand what an agent is doing differently from a single prompt. It's not magic, it's a loop, made visible.

What I got wrong (and how I fixed it)

Mistake 1 — too vague with the goal

Bad prompt: "Research AI agents"

Good prompt:

Research AI agents in enterprise software. Find 3 companies,
what they built, specific results they reported, and format
as: Company | Use Case | Result

Lesson: agents need precise goals just as much as any other system. Garbage in, garbage out — just smarter-sounding garbage.

Mistake 2 — not handling tool failures

Tavily search failed twice on bad queries. My first version just... stopped. Fix: handle_parsing_errors=True, plus retry logic around tool calls. Agents will hit walls — plan for it up front rather than discovering it in production.

Mistake 3 — infinite loops

An early version got stuck re-running the same search fifteen times. max_iterations=10 was the blunt fix; better prompt engineering telling the agent explicitly when to stop was the actual fix.

Mistake 4 — trusting output blindly

The agent confidently cited a statistic from a source that didn't exist. This is the most important lesson in the whole post: agents hallucinate with total confidence. Always validate anything that matters, and build source-checking into the prompt itself rather than trusting the output at face value.

What agents are actually good at (and where they struggle)

After building a few of these, here's my honest read:

Good at:

Repetitive multi-step research
Information gathering and synthesis
Tasks with clear, checkable success criteria
Structured data processing

Struggle with:

Genuinely novel problem-solving
Anything requiring real-world judgment
Information beyond what their tools can reach
Long tasks without checkpoints — they drift from the original goal
Knowing when they're wrong

That last one is the one to internalize. An agent that's confidently wrong is more dangerous than one that visibly fails, because nothing in its own output tells you to double-check it.

Frameworks worth knowing

If you want to go deeper than a single research agent:

LangChain / LangGraph — most mature ecosystem, best docs, largest community. Start here.
CrewAI — multi-agent orchestration, built around "agent teams," a more intuitive API for that specific use case.
AutoGen (Microsoft) — strong for human-in-the-loop agents, research-heavy focus.
LlamaIndex — best fit for document- and data-heavy agents.

A multi-agent setup, with CrewAI

Once one agent works, the natural next step is wiring a few together. Here's a minimal researcher-and-writer crew:

from crewai import Agent, Task, Crew

researcher = Agent(
    role="Research Analyst",
    goal="Find accurate information about {topic}",
    backstory="You're an expert researcher who finds and validates information.",
    tools=[search_tool],
    verbose=True
)

writer = Agent(
    role="Content Writer",
    goal="Write clear, engaging content",
    backstory="You take research and turn it into compelling, accurate writing.",
    verbose=True
)

research_task = Task(
    description="Research {topic} thoroughly",
    agent=researcher,
    expected_output="Detailed research notes with sources"
)

writing_task = Task(
    description="Write an article based on the research",
    agent=writer,
    expected_output="800-word article"
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task]
)

result = crew.kickoff(inputs={"topic": "AI agents in production"})

My honest verdict

AI agents are real and genuinely useful. They're also overhyped in some circles. The truth sits in the middle:

They work well for specific, well-defined tasks.
They're not magic, they need real engineering around them.
They fail in interesting, hard-to-predict ways.
Building one teaches you more in an afternoon than reading about them for a week.

Start simple. One agent, one tool, one task. Get that working before you reach for the autonomous AI company.

What are you building with agents? Drop it in the comments — genuinely curious what's working for people right now.

GitHub Copilot Writes Better Code Than I Did as a Junior. Should Juniors Still Exist?

Jubril Bilal — Thu, 06 Aug 2026 16:18:02 +0000

Provocative question, I know. But it's the real conversation we need to be having not the safe, LinkedIn-friendly version of it.

So here's what I actually think, not the polished take.

The Uncomfortable Reality

The numbers aren't subtle anymore. Stack Overflow's most recent developer survey put AI-tool usage at 84% of developers using or planning to use them up sharply from the year before with roughly half of professional developers now using AI tools every single day. Separate industry surveys this year put daily usage even higher, in the 70-80%+ range depending on how "daily use" is defined.

I don't need the survey data to believe it, though. I see it in my own editor.

Last week I asked Copilot to scaffold a paginated REST endpoint with input validation, error handling, and a matching test file. Ten seconds. When I was six months into my first job, that same task no boilerplate to copy from, half the framework docs still unread took me most of an afternoon. Call it two hours, generously.

That's not a knock on junior-me. That's just the gap. And pretending it doesn't exist doesn't help anyone entering the field right now.

What I've Observed in Code Reviews

I review a mix of AI-generated code and junior-developer code every week, often on the same day, often for the same kind of ticket. The pattern is consistent enough that I trust it now.

The AI code is usually:

✓ Syntactically cleaner
✓ Better commented
✓ More internally consistent

But it's also, just as often:

✗ Missing business context nobody wrote down anywhere
✗ Technically correct but architecturally wrong for where the codebase is headed
✗ Solving the stated problem instead of the real one underneath it

That last point is the one that gets people. A junior developer who's confused will usually ask a question. AI doesn't get confused, it just answers confidently, even when the honest answer was "wait, what are we actually trying to do here?"

The Skills That Actually Survive

Not dying:

→ Systems thinking
→ Code review judgment
→ Understanding requirements vs. implementation
→ Debugging complex production issues
→ Making architectural tradeoffs

Transforming, not disappearing:

→ Syntax memorization becomes prompt engineering
→ Writing boilerplate becomes reviewing AI output
→ Googling solutions becomes validating AI suggestions

Notice the pattern in that second list. None of those skills vanished. They moved one level up the stack, from producing to judging what was produced. That's a real shift in what the job asks of you day to day, but it's not the same thing as the job disappearing.

My Honest Advice for Developers in 2026

If you're junior: don't skip the fundamentals to move faster with AI tools. You need enough hand-built pain in your history to recognize when the AI's confident answer is wrong. That instinct doesn't come from reading about bugs, it comes from having chased a few yourself at 11pm.

If you're mid-level: this is probably the best moment of your career to lean into AI tooling hard. You have enough context to catch its mistakes and enough time-poverty to actually benefit from the speed. Use it aggressively, but keep reviewing its output like you'd review a smart, overconfident intern's.

If you're senior: your job is shifting toward review, architecture, and judgment calls faster than almost anyone else's. That's not a demotion it's the part of the job AI can't touch yet. Get explicit about mentoring juniors on the why, because that's the thing AI still can't hand them.

The Practical Experiment

I ran an informal test on a real ticket, nothing scientific, just three attempts at the same task:

A junior developer (about 6 months of experience), given the ticket cold.
ChatGPT alone, given a detailed prompt with the same requirements.
ChatGPT guided by someone with solid code knowledge, iterating on the same prompt.

Honest breakdown: the junior developer took the longest and made the most syntax-level mistakes, but asked the best clarifying questions and caught an edge case in the requirements that both AI attempts missed entirely. ChatGPT alone was fast and clean but quietly made an assumption about the data model that would have caused a production bug, nothing in the code looked wrong. The guided attempt was the strongest of the three: same speed as AI alone, but the person in the loop caught the bad assumption before it shipped.

The lesson wasn't "AI wins" or "junior wins." It was that the best result came from a human with judgment steering the tool, and that the human didn't need to be senior to do it. They needed to know enough to ask the right question at the right moment.

Conclusion

The floor for "good enough" code is rising fast. Almost anyone can now produce something that runs, passes basic tests, and looks clean.

The ceiling for "exceptional" judgment is rising faster. And that's the part nobody's automated yet.

Juniors aren't obsolete. What "junior" means is changing and the ones who'll do fine are the ones building judgment on purpose, not just accepting whatever the autocomplete suggests.