Pinned Tweet
#jobsearch @kirat_tw
On day 3 of looking for the job, I gave my first interview & these are some questions that the owner asked why backend? why did you choose these technologies? go through and explain the codebase of your favorite project & explain it to me like I'm a newbie
6
358
Deepesh Genani retweeted
932,791 pull requests. 116,211 repositories. 72,189 developers!
That is the scale of a recent GitHub dataset of agent-authored pull requests. Researchers tracked PRs written by five leading AI coding agents across real open-source projects.
AI agents have moved from producing code in isolation to proposing changes in real software projects, they are now opening PRs in real projects at scale.
A second study analysed 7,156 of those pull requests by task type. Documentation changes were accepted 82.1% of the time, while new-feature changes were accepted only 66.1%. The gap suggests that agents perform better on clearly scoped tasks than on changes that require deeper product and architectural judgment.
Writing the code is becoming easier, but making sure the product behaves as intended is still the difficult part, and it is where most changes fail during review.
Take a request like "add configurable request timeouts." The agent can generate code that compiles, passes tests and still ships the wrong behaviour. Should a timeout return 408 or 504? Is the setting global or per route? Does the failure retry or terminate?
We have to understand that a working implementation is not necessarily the right implementation.
And the quality of an implementation is often decided before any code is written. The agent should first investigate the repository, find similar implementations and follow the conventions already in the codebase. Then it should surface only a few critical questions: the ones that change product behaviour, failure semantics or rollout scope. Once those decisions are clear, it can write an evidence-backed specification and a phased plan, before it starts writing code.
Most agent-authored PRs go wrong not because of agent performance, but because developers leave important assumptions unstated and fail to provide the context needed to make the right implementation decisions.
As models continue to improve and code generation becomes cheaper, so now the most useful agents will be those that understand the organisation deeply enough to make the right implementation decisions.
Read the full blog here:
potpie.ai/blog/what-does-it-…
Deepesh Genani retweeted
We are hiring for Forward Deployed Engineers at Potpie!!
Apply Here: binary.so/vUqfa0V
The better the engineering context, the better the agent.
Forward Deployed Engineers at Potpie go into enterprise teams, understand their codebases and workflows, and build that context so agents can deliver real results.
You will go deep into unfamiliar codebases, workflows, and operational reality: how services connect, where context lives across GitHub, Jira, Slack, docs, CI/CD, and incidents, and what it takes to make AI agents actually work in production.
In practice, that means:
• Mapping customer systems and making the Potpie’s engineering context graph
• Turning historical knowledge into durable context the whole organization (and its agents) can use
• Building integrations, agents, and production-ready workflows for debugging, onboarding, and migrations
• Owning discovery, deployment, and pilot-to-production conversion
This is not a solutions-engineering role, Here you write production code. You debug infra, and agents. You ship inside VPC, on-prem, and regulated environments.
Deepesh Genani retweeted
We're hiring Forward Deployed Engineers at Potpie.
Apply here: binary.so/vUqfa0V
In this role, you'll:
- Sit at the intersection of engineering, product and customer deployment, solving hard problems from first principles.
- Work directly with enterprise teams to understand their codebases and workflows.
- Design and deploy AI systems that work in real production environments.
- Build integrations and train agents for customer use cases.
If that sounds like you, apply using the link above.
Deepesh Genani retweeted
During the GPT-4 era, the best way to make AI agents understand a codebase was to first give them a map of the codebase. At Potpie, we built the map by parsing the entire repository into a knowledge graph. It captured things like code structure, dependency connections, and how different modules interacted with each other.
And for a while, this worked well.
The agent could see how files were connected. It could understand where important symbols were defined and could follow how modules depended on each other. This gave the agent a structured starting point instead of making it look at the repository as a collection of random files.
But the enterprise problem is different
Enterprise codebases are not small, clean systems that stay the same forever. They naturally become complex over time. As products grow, teams add new services, create internal patterns, and make architecture decisions that are not always fully captured in documentation.
And most large enterprises also work with huge monorepos.
That is where the old approach started to break.
Parsing the entire monorepo upfront took a lot of time. Before the agent could actually help with the task, it had to wait for the whole repository to be processed. In real enterprise workflows, that waiting time becomes a serious bottleneck.
we at Potpie started asking a different question.
Does the agent really need to understand everything before it starts?
What the agent needs first is enough context to begin. Not the entire repository. Not every file. Not every edge in the graph. Just the context that helps it move in the right direction.
So we stripped away the unnecessary parts and kept the context that actually improves the agent’s performance.
Now, instead of forcing the system to understand everything upfront, Potpie starts with lightweight context such as: repo structure, key files and symbols and high-level dependencies
This gives the agent enough understanding to begin navigating the codebase without starting from scratch.
Then, as the task becomes clearer, Potpie builds deeper context only around the relevant parts.
For example, if the task touches a service, API, or module, the agent can expand into the call graph, related files, recent PRs, and ownership history, around that part of the codebase.
So instead of overwhelming the agent with the entire repository at once, Potpie gives it precise context when it actually needs it.
That is what makes parsing useful in real enterprise workflows.
The agent gets fast context at the start, deeper understanding when the task demands it, and updated context as the codebase evolves. In short, it gets the right context at the right time.
Deepesh Genani retweeted
Before we talk about memory for coding agents, we need to separate it from context. A lot of what gets called memory today is actually context retrieval, or RAG with a better name.
Context is what the agent needs for the task in front of it: a file, a code snippet, a deployment config, a ticket, a log, or a tool result. You retrieve it, put it in the prompt, and the model uses it to answer. This is useful, but it only tells the agent what exists right now.
Memory is different. Memory helps the agent learn from what has already happened.
Say a developer asks an agent to add a new video transcoder microservice with large ffmpeg binaries. The repo uses Docker and GitHub Actions, so from context alone the agent may suggest the standard path: add the service, update the Dockerfile, modify the GitHub Actions workflow, build the image, and deploy.
That sounds correct. But the team may have already learned that this exact approach fails. The last time they tried building images with large binaries on standard GitHub runners, the runner ran out of memory. The fix was to move these builds to a remote Kubernetes builder.
A useful memory layer should bring that lesson back at the right moment. It should not just know, this repo uses GitHub Actions. It should remember, for large binary Docker builds, standard GitHub runners fail here, use the remote builder.
That is the real difference. Context helps the agent understand the current system. Memory helps it avoid repeating the same mistakes.
For coding agents, memory should not be saved chat history or a vector DB full of old conversations. It should be outcome-based lessons from real engineering work: what failed, what worked, why it worked, and when it should be applied again.
That is what makes agents improve over time.
Deepesh Genani retweeted
🚨 Potpie AI is HIRING
8 Roles
Bengaluru
Founder’s Office Intern
Talent Acquisition Intern
Forward-Deployed Engineer
DevOps Engineer
Site Reliability Engineer
Full stack engineer
AI Engineer
AI Researcher
binary.so/potpie-ai
Deepesh Genani retweeted
We’re Hiring🚀: DevOps Engineer at Potpie AI
Use the link below to apply:
binary.so/9mJAmt2
Deepesh Genani retweeted
AI memory isn’t the storage problem people think it is, it’s a reasoning problem.
In our latest blog, we break down why today’s AI “memory” often feels shallow, disconnected, or just plain unhelpful and why that’s not a storage issue but a cognitive one.
👀 Most tools treat memory like a vector database of past facts. But real memory isn’t about storing keywords, it’s about understanding why decisions were made, what worked, and how context influences outcomes.
Our engineer (DBA: Memory Mechanic) @deepesh_genani dives into this challenge and explains how Potpie approaches it differently by moving beyond simple retrieval and into structured, graph-based reasoning that helps AI agents truly learn from experience.
⏳ Why this matters:
• Better memory means AI agents that adapt to your style and decisions
• Fewer repeated explanations from you
• More intelligent recommendations grounded in context, patterns, and outcomes
Whether you’re building with AI or wrestling with the limitations of existing tools, this piece offers a fresh lens on one of the hardest problems in AI today.
✍ Read the full post: potpie.ai/blog/ai-memory-is-…
Deepesh Genani retweeted
A meaningful moment for us at @potpiedotai 🚀
We’ve been featured in Forbes after an in-depth interview with David Prosser on what is truly holding enterprise engineering teams back from adopting AI at scale.
The piece captures a shift we are seeing firsthand:
• AI has made code generation easier, but the real challenge is reasoning across massive, interconnected legacy systems and in non-trivial tasks like debugging.
• “Context” is the missing layer. Decades of decisions across code, tickets, logs, and documentation cannot live in people’s heads anymore.
• Most enterprises are experimenting with AI, but very few have embedded it deeply into production workflows.
• Potpie builds a structured knowledge graph across the codebase so AI agents can operate with the same clarity and safety as a senior engineer to practice spec-driven development.
• Early results are already tangible, including reducing debugging time from nearly a week to 30 minutes for one enterprise customer.
We are already working with large enterprises across healthcare, consumer and fintech, supporting systems with millions and sometimes hundreds of millions of lines of code. The opportunity in front of us is immense. Not incremental productivity gains, but fundamentally changing how complex software systems evolve.
We’re grateful for this recognition. But it is not an individual milestone.
While the story mentions me and @runtimeHorror, Potpie has been built by a much larger circle of belief. Our early investors who leaned in when this was just a sharp point of view. The mentors who pushed us to think bigger. The design partners who trusted us in production. The team that shows up every day to solve hard problems with care.
To everyone who backed us early, advised us, challenged us, introduced us, and believed in this problem before it was obvious. Thank you!
@anupamr, @kushalbhagia, @RTinkslinger, Ravish, @colinevans , Rachel, @rksunchained, @anshpsingh, @DavidTwizer , @ashpreetbedi , @rabi_guha , @GanatraSoham , @xdebstep , @richexplorer_ , @SameerGoyal91, @PuriSid , @maanavsagar, @prasunjain, @nikalank, @hipreetam93, @TsainGra , @vedantm_, @Mandybuoy.
The space is moving fast. Enterprises are ready. The need is real. And we are building with strong conviction. This is just the beginning!
Deepesh Genani retweeted
Spec-driven development, visualized!
Left: “The agents handled it.”
Right: “Cool. Show me the spec.”
Got a review from my Italian client.
If you want to increase your online presence do contact us via pgcafe.pureapps.tech/
@kirat_tw @100xDevs I'm 2025 passout actively looking for Backend dev role,really appreciate if you can refer me.
106
Struggling with multiple Stripe payment flows? I added a type field in metadata to differentiate them. When the webhook triggered, I used the metadata to handle the correct flow & update the DB. Webhooks simplify real-time event handling like payments!
4
212
[1/6] A tricky JavaScript timezone issue in our parking booking app: When users in Italy book for 12 AM, the Postgres DB (neonDB US) stored it as previous day 18:00. Here's why & how we fixed it 🧵
[5/6] Result: DB receives "2024-01-01 00:00:00" instead of a JS Date object. No timezone = no conversion = correct storage of exact selected time.
1
2
57











