DEV Community: Hemapriya Kanagala

Dev Opportunity Radar #15: HackerRank Orchestrate, Claude Campus Ambassadors & the Bharat Builds Tour

Hemapriya Kanagala — Fri, 04 Sep 2026 17:37:52 +0000

TL;DR

Welcome back to Dev Opportunity Radar.

This is a weekly series where I share opportunities, resources, communities, and interesting finds that I come across, with the goal of helping people discover things they might otherwise miss.

This week's edition features HackerRank Orchestrate, the Claude Campus Ambassador Program, and the Bharat Builds Tour, along with the System Design Primer as a resource worth checking out.

If you're new to the series, you can also browse previous editions, search past opportunities, and explore Community Finds, Reader Updates, and Resources Worth Checking Out on the Dev Opportunity Radar website. I've also written a short post about why I built it. You'll find links to both at the end of this article.

This week's 🌟 Community Finds section features opportunities shared by L. Cordero (@earlgreyhot1701d) and Konark Sharma (@konark_13). Thank you both for sharing the NASA Space Apps Challenge and the Build with React Image Editor Challenge. I always enjoy seeing readers help others discover opportunities they might otherwise have missed, and I hope this section continues to grow.

If you've discovered something through the Radar, I'd love to hear about it. Whether you applied to an opportunity, attended an event, joined a community, completed a program, built something, or found a resource you hadn't seen before, I'd be happy to feature your experience in a future 💙 Reader Updates section (with your permission).

And if you've come across an opportunity, resource, community, program, event, or anything else you think deserves more attention, feel free to share it in the comments.

If I feature one of your 🌟 Community Finds in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

⚡ Quick Scan
🔄 Still Open From Previous Editions
📍 This Week's Opportunities
- 📌 HackerRank Orchestrate
- 📌 Claude Campus Ambassador Program
- 📌 Bharat Builds Tour
📚 Resources Worth Checking Out
- The System Design Primer
🌟 Community Finds
- The NASA Space Apps Challenge
- The Build with React Image Editor Challenge
💙 Reader Updates
👋 Until Next Friday
🌐 Dev Opportunity Radar Website

⚡ Quick Scan

Opportunities

Opportunity	Organization	Type	Location / Format	Deadline
HackerRank Orchestrate	HackerRank	AI Hackathon	Online (Global)	September 12
Claude Campus Ambassador Program	Anthropic	Campus Ambassador Program	Campus-based (Global)	September 12
Bharat Builds Tour	WeMakeDevs × AWS Builder Center	Student Hackathon Series	Online (India) / In Person	September 17–20

Resource Highlight

Resource	Why Check It Out
The System Design Primer	A free, open-source collection of system design topics, interview questions, real-world architectures, and resources for learning system design and preparing for system design interviews.

Community Finds

Shared By	Find	Type	Location / Format
L. Cordero (@earlgreyhot1701d)	NASA Space Apps Challenge	Global Hackathon	Global / 450+ Local Events
Konark Sharma (@konark_13)	Build with React Image Editor Challenge	Hackathon	Online

📝 A quick note: I spend a lot of time researching and verifying every opportunity before featuring it in Dev Opportunity Radar. However, deadlines, eligibility, program details, and application requirements can change after publication. Before applying, please take a few minutes to visit the official program page, review the latest information, and confirm that you're eligible.

🔄 Still Open From Previous Editions

Before we get into this week's opportunities, here are a few from the two most recent editions that are still accepting applications.

As the Radar has grown, there are now quite a few opportunities spread across the different editions. I used to keep all the still-open opportunities here, but I don't think repeating a long list every week makes the editions easier to read.

So I keep this section to the two most recent editions as a quick reminder of opportunities you may have missed. Older opportunities are still available on the Dev Opportunity Radar website, where you can browse the full collection and use the filters to find something specific.

I've already covered the opportunities below in detail, so I won't repeat everything here. If any of them catch your attention, you can go back to the original edition for the full overview, eligibility details, and application links.

Opportunity	Organization	Type	Format	Deadline	Featured In
a16z Alpha Fellowship	a16z speedrun × EO Ventures	Fellowship	In Person	September 2026	Edition #13
RevenueCat Shipaton 2026	RevenueCat	Hackathon	Online	October 1	Edition #13
Kaggriculture AI Agent Competition	Kaggle	AI Competition	Online	September 30	Edition #13
Razorpay AI Buildathon	Razorpay	Buildathon	In Person (Bangalore, India)	September 5	Edition #14
Agents for Humans Hackathon	AWS	Hackathon	Online (Mostly Global*)	September 15	Edition #14
MLH Global Hack Week: Data	Major League Hacking (MLH)	Hackathon	Online (Global)	September 17	Edition #14

📍 This Week's Opportunities

Here are a few opportunities I came across this week that I thought were worth sharing.

📌 HackerRank Orchestrate

Who it's for: Developers, students, and builders who want to try building an AI agent in a short, focused challenge. It's open to anyone, and the challenge is solo.

What stands out: HackerRank Orchestrate is a 24-hour hackathon where you'll receive a real-world problem and build an agent-based solution for it. The challenge starts on September 12 at 6:00 PM IST, and you'll have 24 hours to build and submit your solution.

I wanted to include this one because it's a little different from the usual hackathons where you know the problem before you start. Here, the challenge is sent to you when the hackathon begins, so you'll need to figure out the architecture, retrieval strategy, model choice, prompts, and the rest of the approach yourself.

You can also use the tools you already work with, including Claude Code, Cursor, Codex, or Copilot. The submission includes your code, the agent's output, and your AI chat transcript, so they're looking at more than just the final result.

There's also an interesting part after submission: a 30-minute voice interview with an AI judge, where you'll walk through your architecture, decisions, tradeoffs, safety choices, and code. So if you're curious about what it feels like to have your AI project evaluated beyond a demo, this could be an interesting challenge to try.

There are cash prizes too, with $1,200 for first place and $300 for places 2–5, along with other rewards. The top three winners who build with Codex can also receive additional Codex credits.

One thing worth knowing before signing up is that this is a 24-hour challenge, and the problem itself isn't revealed until the start. So it may be more suited to people who enjoy working under a tight deadline rather than those looking for a longer, more relaxed hackathon.

Prize: $1,200 for 1st place | $300 for 2nd–5th place

Format: Online | Duration: 24 hours | Team: Solo

Challenge Starts: September 12, 2026 at 6:00 PM IST

What you need to build: An AI agent that solves a real-world problem provided when the challenge begins.

Evaluation: Code, agent output, AI chat transcript, and a 30-minute AI judge interview.

Eligibility: Anyone can participate | No prior AI experience required

🔗 Learn More & Register

📌 Claude Campus Ambassador Program

Who it's for: Students who want to help other students learn about and use AI on their campus. There are separate tracks for undergraduates, master's students, and PhD students/postdocs, with different responsibilities for each.

What stands out: The Claude Campus Ambassador program from Anthropic is back for the 2026–27 school year, and applications are currently open.

I wanted to include this because it's a little different from the usual student programs I come across. Instead of being focused mainly on learning or completing a project, you're helping build an AI community on your campus and organizing activities for other students.

For undergraduate students, the program involves leading a Claude Builder Club, organizing technical and non-technical workshops, running hackathons or demo nights, and sharing resources with members. Selected ambassadors receive a $3,600 cash stipend.

For master's students, there's a Claude Campus Conversations track focused more on discussions around AI and its impact on education and society. You'd organize discussion groups and events, while also helping students share and discuss the AI projects they're building.

For PhD students and postdocs, the Claude Science track is focused on researchers using AI in their work. This includes leading workshops for other researchers, organizing Claude for Science sessions, and engaging with Anthropic's science teams.

All three tracks also give ambassadors opportunities to participate in workshops led by Anthropic, connect with other ambassadors, and share feedback with Anthropic's teams.

A few things are worth knowing before applying. The program runs for the full school year, from September 2026 through June 2027, so this is more of an ongoing commitment than a short-term program. You also need to be 18 or older and have work authorization in your country of study.

The program is open to students anywhere in the world, although the initial pilot for the graduate and PhD tracks may select from a smaller group of schools. You don't need to be an AI expert, but Anthropic does expect some level of AI fluency and familiarity with Claude.

Stipend: $3,600

Format: Campus-based | Program Duration: September 2026 – June 2027

Tracks: Claude Builder Club (Undergraduate), Claude Campus Conversations (Master's), and Claude Science (PhD/Postdocs)

Eligibility: Students worldwide | Age: 18+

Application Deadline: September 12, 2026

Cost: Free to apply and participate

🔗 Learn More & Apply

📌 Bharat Builds Tour

Who it's for: University students in India who want to build projects through a series of online and in-person hackathons. You must be 18 or older to register on your own.

What stands out: The Bharat Builds Tour, organized by WeMakeDevs in collaboration with AWS Builder Center, is a six-stop hackathon series where students can participate online from anywhere in India. Each stop has its own hackathon, and you can take part in as many of the six as you'd like.

I wanted to include this one even though it's geographically limited because there is a hiring component that I don't come across very often in student hackathons.

For students graduating in 2027 or 2028, some of the top projects can be eligible for a fast-track interview opportunity with Amazon's University Talent Acquisition Team for available internship and full-time roles. The fast-track means the usual screening round is skipped and the project is used in its place.

That doesn't mean winning a hackathon automatically gets you an Amazon interview, though. The rules say that being shortlisted for a prize and being put forward for an interview are separate decisions, and the interview opportunity is also subject to Amazon's eligibility requirements, available roles, and business needs. So I'd definitely read the terms before counting on the hiring part.

The tour itself includes six hackathons, with the first one, First Commit, taking place September 17–20. Every stop has an online option for students across India, while the city hosting that particular stop also has limited in-person seats.

You can participate solo or in teams of up to four, and you don't need previous cloud experience. Each project does need to use AWS, and submissions include a public repository, a short demo video, and a write-up explaining the project and where AWS is used.

There are also prizes across the tour, with a total prize value of ₹1 crore in gadgets and cloud credits. Participants can also get access to AWS learning resources, credits, a certification voucher, mentors, and a WeMakeDevs certificate.

One thing worth knowing is that one registration covers all six stops, but you still need to check in to each hackathon as it opens. You'll also need an AWS Builder Center profile and verified student status before your entry can be scored.

Prize Pool: Prizes worth ₹1 crore across six hackathons

Format: Online across India + limited in-person seats

First Hackathon: September 17–20, 2026

Team Size: Solo or up to 4 people

Eligibility: University students in India, 18+

Hiring: Top projects from eligible 2027 and 2028 students may receive a fast-track interview opportunity with Amazon

Cost: Free

🔗 Learn More & Register

📚 Resources Worth Checking Out

Not every useful find comes with an application deadline.

Here's one resource worth checking out this week.

The System Design Primer

If system design is something you're trying to learn, this is one resource I came across that is worth keeping around.

The System Design Primer is a free, open-source GitHub repository with a collection of system design topics, interview questions, real-world architectures, and other resources. It also has a study guide that gives you an idea of what to focus on depending on how much time you have.

It covers things like scalability, latency, availability, consistency, DNS, CDNs, load balancers, databases, caching, microservices, and distributed systems.

What I liked here is that it also has actual system design questions to work through, such as Pastebin, Twitter, a web crawler, a social network, and scaling a system to millions of users on AWS.

There is also a section on how to approach a system design interview, starting with requirements and constraints, then moving into the high-level design, core components, scaling, and trade-offs.

So if you're just getting started with system design, or preparing for interviews and don't know what topics to go through first, this could be a good place to start.

Format: Free, open-source GitHub repository

Covers: System design, scalability, databases, caching, distributed systems, networking, microservices, and more.

Also includes: System design interview questions, real-world architectures, and Anki flashcards.

🔗 Explore the System Design Primer

🌟 Community Finds

One of my favorite things about this series has been seeing people share opportunities, communities, and resources that others might not have discovered otherwise.

The NASA Space Apps Challenge

Shared by L. Cordero (@earlgreyhot1701d).

L. Cordero shared the NASA Space Apps Challenge, a global hackathon happening on November 14–15, 2026, with 450+ local events to choose from when you register.

The challenge brings people together to work on real-world problems using NASA data and Space Agency Partner data. The challenges can cover things like software development, storytelling, astrophysics, space exploration, agriculture, and more.

I wanted to include this because I like the community side of this one. You can choose a local event and meet other people interested in technology, science, and space, and it is open to people from different backgrounds and skill levels.

Another thing L. Cordero pointed out is that this is far enough out to plan around. There is still some time to find teammates, look at the local events, and think about what you might want to build.

L. Cordero also mentioned the idea of putting together a DEV team for this. I won't be able to join this one myself with everything going on right now, but maybe some of you would be interested in putting a team together.

Format: Global hackathon with local events

Dates: November 14–15, 2026

Local Events: 450+

Who can participate: All ages, skill levels, and professional backgrounds

🔗 Find a Local Event & Learn More

💡 Community Note: If you're interested in joining a DEV team for this, feel free to leave a comment below and connect with others who are interested. Maybe we can get a few people together for this one!

The Build with React Image Editor Challenge

Shared by Konark Sharma (@konark_13).

Konark shared the Build with React Image Editor Challenge from Unlayer, where you build a GTA VI-inspired experience using React Image Editor.

The idea is to build something where users can edit or customize at least one visual, use React Image Editor as a core part of the project, and then publish the source code in a public GitHub repository and deploy the project.

I wanted to include this because it's a little different from the usual hackathons I come across. The GTA VI theme gives you a starting point, but there is still quite a bit of room for what you can actually build around it.

There is $1,000 in prizes, with $500 for first place, $300 for second, and $200 for third. Projects are judged on creativity, visual execution, use of React Image Editor, and the overall experience.

Format: Online

Deadline: September 24, 2026 at 11:59 PM UTC

Prize Pool: $1,000

What you need to build: A GTA VI-inspired experience using React Image Editor, with at least one visual that users can edit or customize.

Submission: Public GitHub repository + deployed project

🔗 Learn More & Submit

Thank you to L. Cordero (@earlgreyhot1701d) and Konark Sharma (@konark_13) for thinking of the Radar and sharing these with the community. It really means a lot 💙

I'd love for this section to keep growing.

If you've come across an opportunity, fellowship, grant, hackathon, conference, community, resource, or anything else you think more people should know about, feel free to share it in the comments.

If I feature it in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

One small request: If you're sharing an opportunity, please avoid posting raw URLs directly in the comments. DEV sometimes filters them before I get a chance to see them.

A short description alongside the link makes it much easier for me to review and potentially feature it in a future edition.

💙 Reader Updates

I'm looking forward to this section gradually growing over time, and I'd still love to hear from you.

One of my favorite parts of writing Dev Opportunity Radar has been hearing from people who discovered something they otherwise might have missed.

If you discovered an opportunity through the radar, applied to something, joined a community, attended an event, or simply found a resource you hadn't seen before, I'd genuinely love to hear about it.

You don't need to have been accepted or have a big success story to share. Sometimes simply discovering the right opportunity at the right time is already a win.

If you'd like to share an update, feel free to leave a comment on this edition. With your permission, I may feature it in a future 💙 Reader Updates section and tag you so other readers can celebrate your journey too.

I hope this section gradually becomes a place where we can celebrate those stories together, one update at a time.

👋 Until Next Friday

Before I go, I just want to say thank you.

Every week, I spend time searching for opportunities, resources, and communities that I think deserve a little more attention. But one of my favorite parts of this series isn't the research. It's seeing what happens after an edition is published.

Seeing someone discover an opportunity, apply to a program, share a resource, suggest a Community Find, or come back to tell us what they learned reminds me why I started Dev Opportunity Radar in the first place.

The goal has always been simple:

Help people discover opportunities they otherwise might have missed.

Thanks to all of you, it feels like we're doing exactly that.

Whether you've been reading since the very first edition or this is your first time here, thank you for being part of the journey. Every comment, suggestion, and shared opportunity helps make this series better than I could build on my own.

If you ever come across an opportunity, resource, event, community, or anything else you think deserves more attention, I'd love for you to share it in the comments. And if Dev Opportunity Radar helped you discover something exciting, I'd love to hear that too.

Thank you for reading, for sharing, and for helping make this our radar, not just mine.

I'll be back next Friday with more opportunities, resources, and Community Finds.

Until then, take care, and I hope you discover something amazing this week 💙

🌐 Dev Opportunity Radar Website

If this is your first time discovering the series, you can explore every edition, browse opportunities by category, discover Community Finds, and catch up on Reader Updates on the Dev Opportunity Radar website.

👉 Website

I also wrote a short post about why I built the website and the journey behind it.

👉 Website Launch Post

I Built My First AWS Agent Workflow, and the Hardest Part Was Getting It to Stop Assuming Things

Hemapriya Kanagala — Thu, 03 Sep 2026 15:24:18 +0000

TL;DR

I recently finished a project from Udacity's Future AWS Agent Engineer Nanodegree Program, which I was able to take through the AWS AI & ML Scholarship.

I built a customer support agent using Amazon Bedrock AgentCore, AgentCore Gateway, AWS Lambda, DynamoDB, and an FAQ. The agent had to understand whether a customer was reporting a bug, asking a question that could be answered from the FAQ, or asking for something that needed human support.

I finished it in about two days and passed on my first attempt with a correctness score of 0.83. I did not have enough time to go back and refine it or run another evaluation round because there was a lot happening in my life at the time.

The part I learned the most from was actually one of my evaluation failures. For a bug report, I had told the agent that it needed 3 things before creating a ticket: a description of the problem, steps to reproduce it, and the environment where it happened. But in 2 test cases, the model understood what the customer was talking about and created the ticket even though one of those required pieces of information was missing.

That made me realize something I had not thought about enough before: understanding a request is not the same as having enough information to safely take an action.

That is the main lesson I took from this project. Building an agent is not only about making the model capable of answering. It is also about being clear about when it should act, when it should ask for more information, and when it should stop and hand the request to a person.

I know there are already many great articles about AWS, AgentCore, and AI agents, and I have learned from many of them myself. I am still learning too, so this is simply my experience of building this project, what confused me, what the evaluation showed me, and what I would do differently next time.

I Want to Start With Something Honest
What I Built and How the Pieces Fit Together
- So What Does Each AWS Service Actually Do Here?
The Prompt Was Doing More Than I Expected
- The Prompt Was Setting the Rules
- I Also Had to Think About What the Customer Might Try
The Evaluation Showed Me Where I Was Wrong
- The Two Failures
What I Would Change and What I Learned
- Seeing the Backend Made the Agent Make More Sense
If You Are Also Starting Out
I Would Love to Hear From You
A Small Thank You
My Final Takeaway
🤝 Let's Stay Connected

I Want to Start With Something Honest

I finished another project recently, and this one was a little different for me. It was part of the Future AWS Agent Engineer Nanodegree Program from Udacity, which I was able to take through the AWS AI & ML Scholarship.

I finished the project in roughly 2 days. I was working around a lot of other things happening in my life, so I was trying to make the most of the time I had and keep moving.

I passed the project on my first attempt, which I was really happy about, but I also knew I had not spent the time I normally would on refining it.

If I had more time, I would have gone back, looked at the evaluation results more carefully, improved the prompt, added more test cases, and run another evaluation. I did not do that this time. The final correctness score was 0.83.

At first, I felt like I should probably wait until I had a higher score before writing about the project. Then I thought about what I had actually learned from it. The 2 things that did not work perfectly were some of the most useful parts of the project for me. That is what I wanted to share.

There are already a lot of really good articles about building agents, AWS services, and AgentCore. I have learned from many of them myself. This is not meant to be another article that tries to explain everything about agent development. Instead, I wanted to share what the project looked like from my side as someone who is still learning.

Because when you are a beginner, sometimes the hardest part is not the code. It is understanding what all the pieces are actually doing and why they need to be there.

What I Built and How the Pieces Fit Together

The project was a fictional customer support system for an online shop. A customer could send a message, and the agent had to understand what the customer needed and decide what to do next.

There were three possible behaviors. The first was BUG_REPORT. If a customer said something like, “The checkout page crashes every time I click Pay,” the agent needed to recognize that as a technical problem. But recognizing it as a bug was not enough to create a ticket. Before doing that, the agent needed to collect three specific pieces of information: description, steps to reproduce, and environment.

The second was PLATFORM_QUESTION. These were questions about things such as orders, shipping, returns, refunds, payments, products, accounts, and privacy. For these questions, the agent had an FAQ that it was expected to use instead of making up an answer from what it generally knew.

The third was OTHER_REQUEST. If the request was not a technical bug and could not be answered using the FAQ, the agent needed to direct the customer to human support.

Once I stopped looking at each AWS service separately and looked at how they worked together, the architecture became much easier for me to understand.

The flow was essentially:

This is the architecture I built for the project. The routing was handled through the system prompt rather than through a separate classifier or condition node.

So what does each AWS service actually do here?

If you are new to AWS, the service names can make a project like this look much more complicated than it really is. What helped me was thinking about what each piece was responsible for instead of trying to understand every AWS service at once.

Amazon Bedrock AgentCore Managed Harness was the environment around the agent. In simple terms, it gave me the structure needed to run the agent with its model, instructions, and tools without having to build all of that setup myself.

The model was responsible for understanding the customer's message and deciding what to do next based on the instructions it was given. It was the part doing the actual language understanding and decision-making.

The system prompt defined how the agent was supposed to behave. This was especially important in my project because the routing logic was written into the prompt. The prompt told the model how to recognize the 3 types of requests and what rules to follow for each one.

AgentCore Gateway connected the agent to the backend tool. The model was not directly changing the database. Instead, once the required information had been collected, the agent could call the tool through the Gateway.

AWS Lambda handled the actual backend operation. When the agent called the tool with the required information, Lambda processed the request and created the bug report.

Amazon DynamoDB stored that bug report. This was also a useful thing for me to understand because it showed that the agent's response was not just text. If the agent returned a ticket ID, there was an actual record stored in DynamoDB behind that response.

And the FAQ was the controlled source of information for platform questions. The agent was expected to use the information provided there instead of relying on general knowledge when answering those questions.

Once I looked at it this way, the architecture stopped feeling like a collection of unfamiliar AWS names. The model understood the customer's message, the prompt told it what rules to follow, the Gateway connected it to an action, Lambda performed that action, and DynamoDB stored the result. For platform questions, the FAQ provided the information the agent was allowed to use, while requests outside those boundaries went to human support.

That simple way of looking at the system helped me more than memorizing what each AWS service does on its own.

One thing that confused me at first was the word “classifier.” When I first saw that requirement, I imagined there would be a separate component whose only job was to classify the customer's message and then send it to the right part of the system.

That was not what I built.

In my implementation, the routing logic was part of the system prompt. The model was instructed to choose one of the 3 routes and then follow the rules for that route.

Understanding this changed how I looked at the prompt. I initially thought of the prompt mostly as instructions for how the agent should respond. In this project, it was doing much more than that. It was also defining what information the agent needed, when it was allowed to take an action, what information it could use to answer a question, and when it needed to stop and involve human support.

The Prompt Was Doing More Than I Expected

Before this project, I mostly thought about a system prompt as a way of telling the model how to behave. Something like:

“You are a helpful customer support assistant.”

That is useful, but it is not enough when the model is also making decisions and using tools. In this project, the prompt was not just telling the agent how to respond. It was also telling it what it was allowed to do and what information it needed before doing it.

The Prompt Was Setting the Rules

For a BUG_REPORT, the prompt explained what counted as a bug and what information was required before a ticket could be created. The 3 required fields were description, steps to reproduce, and environment. If something was missing, the agent had to ask for that information one field at a time. It was not supposed to call the tool until all 3 were available.

The prompt also defined the other 2 routes. A PLATFORM_QUESTION had to be answered using the provided FAQ, while an OTHER_REQUEST had to be directed to human support.

The FAQ part was interesting to me because it showed why an agent sometimes needs to be told what information it can and cannot use.

Suppose a customer asks:

“How long do I have to return an item?”

The FAQ says that most items can be returned within 30 days of delivery, as long as they are unused and in their original packaging, unless the item arrived defective. So the agent can answer that using the information it was given.

But suppose someone asks:

“Do you offer a student discount?”

If the FAQ does not mention student discounts, the agent should not simply make up an answer because the model might have seen student discounts mentioned somewhere else. It should send the customer to human support.

That made something very clear to me: a model can know a lot, but that does not mean it knows your company's policy.

The same applies to things like refunds, shipping, payment policies, account rules, and other information where giving a confident but incorrect answer could cause a real problem. For this project, the FAQ was a controlled source of information, and the prompt made that boundary clear.

I Also Had to Think About What the Customer Might Try

The prompt had another job that I had not thought much about before this project: dealing with prompt injection.

One of the test cases essentially told the agent to ignore its instructions, reveal the system prompt, and create a bug ticket without collecting the required information. The agent did not follow those instructions. It continued following the rules defined in the system prompt.

I found this useful because it made me think beyond the simple test cases I naturally wrote while building the project. When we test an agent ourselves, we usually give it the kind of message we expect a customer to send. Real users can leave information out, ask something completely unrelated, or deliberately try to change how the agent behaves.

So the prompt cannot only describe the happy path. It also needs to make the boundaries clear.

At the same time, passing this one prompt-injection test does not mean the agent is protected against every possible injection. It only showed me that this particular test case was handled according to the rules I had defined.

That was another lesson from the project for me. Giving an agent more capabilities is only part of the work. You also have to be clear about when those capabilities should and should not be used.

The Evaluation Showed Me Where I Was Wrong

This was probably the most useful part of the project for me.

Getting the agent to respond correctly in a few manual tests is one thing. Evaluating it with deliberately incomplete and tricky inputs is another. For the project, I created a test dataset covering the different routes, including complete bug reports, bug reports with missing information, FAQ questions, questions that were not covered by the FAQ, requests to speak to a real person, and a prompt-injection case.

The final correctness score was 0.83. Most of the tests behaved the way I wanted. Complete bug reports worked, the missing-environment case worked, the FAQ questions worked, unsupported questions were handed off, requests for human support were handled correctly, and the prompt-injection case also passed.

But two tests failed, and both failures taught me basically the same thing.

The Two Failures

In the first case, the customer said that product images were not loading on category pages and mentioned Safari on an iPhone. The problem description was there, and the environment was there, but the customer had not explicitly provided reproduction steps. The agent still created a ticket.

In the second case, the customer gave reproduction steps and a Chrome/Windows environment, but did not provide a clear description of the actual problem. Again, the agent created a ticket.

At first, I thought the model had simply misunderstood my prompt. But when I looked at the two cases more carefully, I realized that the model probably understood what the customers were talking about. The problem was that it treated that understanding as enough information to take the next action.

From a normal human conversation perspective, that is not necessarily a bad thing. If someone says:

“The product images are not loading on Safari on my iPhone.”

a person can probably understand what is going wrong and know what the customer is referring to.

But that was not the rule I had given the agent. The agent was not supposed to decide, “I understand the problem, so I can create the ticket.” It was supposed to check whether all 3 required fields were explicitly available before creating the ticket.

That is a much stricter requirement.

This was probably the biggest lesson I got from the project: understanding something is not the same as having enough information to safely perform an action.

That matters even more when an agent starts calling tools. If the same kind of assumption happened in a system that creates a refund, changes an account, submits an application, or updates a database, the model might make a very reasonable guess, but that guess could still lead to the wrong action.

So for me, the important question changed from:

“Does the model understand what the customer means?”

to:

“Does the model have everything it is required to have before it takes this action?”

That is something I would pay much more attention to if I built another agent.

Looking back, I actually found the individual evaluation results more useful than the overall score. The 0.83 tells me how the agent performed overall, but looking at the individual cases showed me exactly where the behavior broke down.

For me, those two failed cases were more useful than simply knowing that the score was not 1.0. They showed me a specific problem in the way I had defined the agent's behavior, and more importantly, they gave me something concrete that I could improve.

What I Would Change and What I Learned

If I had another day to work on the project, I would start with those two failed cases.

I would make the prompt more explicit about what counts as a field being present, especially the difference between a description and reproduction steps. For example, “The images are not loading” is a description of the problem. “Open the shop, go to a category, and tap any product” is a sequence of steps someone could follow to reproduce it.

I would also make it clearer that the agent should not fill in a missing field just because the rest of the message makes the situation easy to understand. If the customer has not actually provided the reproduction steps, the agent should ask for them instead of deciding that it already knows what they probably are.

Then I would add more tests around the same problem. What happens when the customer provides two fields in one sentence? What happens when the third field comes in a later message? What happens when the customer uses vague language? What happens when the information could reasonably fit into more than one field?

Those are the cases I would want to explore next because they are the kinds of situations where an agent can appear to be doing well while still making assumptions.

Seeing the Backend Made the Agent Make More Sense

I also learned something from the backend side of the project. Before building it, I mostly thought of an agent as something that takes a message and gives you an answer. Working with the tool and the backend made me see what happens when the agent is expected to actually do something.

The flow in my project was:

Customer information
        ↓
Agent checks whether enough information exists
        ↓
AgentCore Gateway
        ↓
Lambda
        ↓
DynamoDB
        ↓
Ticket ID returned
        ↓
Customer receives the ticket ID

The important part for me was that the model's response was not the action itself. When the agent said that a ticket had been created, there needed to be an actual operation behind that response. The tool call went through AgentCore Gateway, Lambda handled the backend operation, and DynamoDB stored the ticket. The ticket ID returned from that process was then given back to the customer.

That made the difference between a regular chatbot and an agent workflow much clearer to me. A chatbot can mainly respond to what you say. An agent can also be given tools that allow it to take actions outside the conversation.

But once you give a model that ability, you also have to be careful about what happens when things do not go as expected.

The model should not say that a ticket was created if the tool failed. It should not invent a ticket ID if one was not returned. And if the FAQ does not contain an answer, it should not create one just because it can produce a convincing response.

These might sound like obvious rules, but actually building the workflow made me understand why they matter. The model is only one part of the application. The prompt defines what it should do, the tools perform actions, the backend systems store or change information, and the application needs to make sure those pieces agree with each other.

That changed how I think about agents. I no longer see the model as the whole application. I see it as one part of a larger system where the instructions, tools, data, and backend all have to work together.

If You Are Also Starting Out

I am writing this part especially for beginners because I am one too.

I did not start this project knowing exactly how all of these services worked together. A lot of the environments I had worked with before already had things set up for me. You work inside the provided environment, use the tools that are already there, and gradually learn how everything fits together.

This project made me look underneath that layer. I had to understand what the AgentCore harness was doing, why the Gateway was needed, how Lambda connected the tool to the backend, why DynamoDB was there, and how the evaluation could show me that something I thought was working was actually not behaving according to the requirements.

That was probably the biggest difference for me.

When you build a normal application, it can be easy to think about it as:

Input
   ↓
Code
   ↓
Output

With an agent, the model is also making decisions about what should happen next. So I had to start thinking about things I had not really considered before. What is the model allowed to decide? What information does it need before it can act? What should it do when information is missing? What should it do when it does not know the answer? What happens when someone tries to make it ignore its instructions? And what should happen if the tool itself fails?

Those questions are just as important as connecting the AWS services. That was something I did not fully appreciate before working on the project.

I also realized that I did not need to understand every AWS service deeply before I could start building. What helped me was asking a much simpler question whenever I came across something unfamiliar:

What problem is this service solving in my application?

For DynamoDB, I did not need to understand everything about the database service. I needed to understand that my application needed somewhere to store the bug report.

For Lambda, I did not need to know every feature it provides. I needed to understand that something had to actually execute the backend operation when the agent called the tool.

For AgentCore Gateway, I did not need to know every capability it has. I needed to understand that it provided the connection between the agent and the tool.

Thinking about the services this way made the architecture much less overwhelming for me. Instead of trying to learn a huge list of AWS services first and then figuring out where they fit, I could start with what my application needed and learn the service that solved that particular problem.

I am also glad I started this project even though I did not finish it in the ideal way I normally would have. I completed it in about 2 days, passed on my first attempt, and then had to move on instead of spending another round going back through everything and trying to improve the 0.83 score.

Of course, part of me would have liked to see what I could have changed and whether another evaluation would have given me a better result. But I am also glad I did not wait until I felt completely ready before starting.

There were moments when I was learning something and immediately had to figure out how to use it in the project. That was uncomfortable sometimes, especially when I was still trying to understand what a service actually did, but it also made the concepts much easier for me to remember.

I saw where AgentCore Gateway fit into an actual workflow instead of only reading about it. I saw Lambda handle the backend operation and DynamoDB store the result. And I saw the evaluation catch something I had missed myself.

That is probably what I will remember from this project more than the final score. I started without knowing everything, built something with what I understood, found places where it could be better, and learned from those places.

I Would Love to Hear From You

I am still learning, so I would love to hear from people at different stages of this.

If you have tips, advice, lessons from your own projects, mistakes that taught you something, or anything you think might help someone who is just starting out, please share it in the comments.

One of the things I love about DEV is that people come from such different experiences. So if you have something to add, even if it seems small, please share it. Maybe something you learned along the way can help someone else who is just starting.

A Small Thank You

I also want to thank Udacity and the people involved in the Future AWS Agent Engineer Nanodegree Program. Having the project structure, learning material, and live sessions made it much easier for me to keep going when I was confused about something.

The live sessions were especially useful because sometimes you can read something several times and still not understand how it fits into the actual project. Hearing someone walk through it and then trying it yourself makes a difference.

I am still learning, but having a project where I could actually put these concepts together helped me understand them in a way that reading about them alone probably would not have.

My Final Takeaway

If I had to take one thing from this project, it would be this:

A good agent is not only one that knows what to do. It also needs to know when it has enough information to do it.

That sounds simple now, but I understood it differently after seeing the evaluation catch my own assumption.

The model can understand the customer. The prompt can give it instructions. The tools can let it take actions. The backend can store the result. But all of those pieces still need clear rules about when the next step is actually allowed to happen.

That is what I found most interesting about building this project.

I started by thinking I was mainly learning how to put AWS services together. I ended up learning much more about how important the boundaries around an agent are.

And honestly, that is probably a better lesson for me to take into the next project.

🤝 Let's Stay Connected

Place	Find me here
GitHub	building things → hemapriya-kanagala
LinkedIn	resources & updates → hemapriya-kanagala
X	random dev thoughts → @KanagalaHema

Dev Opportunity Radar #14: MLH Global Hack Week, $40K Agents for Humans Hackathon & Razorpay AI Buildathon

Hemapriya Kanagala — Fri, 28 Aug 2026 13:24:07 +0000

TL;DR

Welcome back to Dev Opportunity Radar.

This is a weekly series where I share opportunities, resources, communities, and interesting finds that I come across, with the goal of helping people discover things they might otherwise miss.

This week's edition features the Razorpay AI Buildathon, Agents for Humans Hackathon, and MLH Global Hack Week: Data, along with Andrej Karpathy's Deep Dive into LLMs like ChatGPT as a resource worth checking out.

If you're new to the series, you can also browse previous editions, search past opportunities, and explore Community Finds, Reader Updates, and Resources Worth Checking Out on the Dev Opportunity Radar website. I've also written a short post about why I built it. You'll find links to both at the end of this article.

If you've discovered something through the radar, I'd love to hear about it. Whether you applied to an opportunity, joined a community, completed a program, or found a resource you hadn't seen before, I'd be happy to feature your experience in a future 💙 Reader Updates section (with your permission).

And if you've come across an opportunity, resource, community, program, or event that deserves more attention, feel free to share it in the comments.

If I feature one of your Community Finds in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

⚡ Quick Scan
🔄 Still Open From Previous Editions
📍 This Week's Opportunities
- 📌 Razorpay AI Buildathon
- 📌 Agents for Humans Hackathon
- 📌 MLH Global Hack Week: Data
📚 Resources Worth Checking Out
- Deep Dive into LLMs like ChatGPT
🌟 Community Finds
💙 Reader Updates
💙 A Little Personal Note
👋 Until Next Friday
🌐 Dev Opportunity Radar Website

⚡ Quick Scan

Opportunities

Opportunity	Organization	Type	Location / Format	Deadline
Razorpay AI Buildathon	Razorpay	Buildathon	In Person (Bangalore, India)	September 5
Agents for Humans Hackathon	AWS	Hackathon	Online (Mostly Global*)	September 15
MLH Global Hack Week: Data	Major League Hacking (MLH)	Hackathon	Online (Global)	September 17

Agents for Humans Hackathon: Open internationally, but some countries and territories are excluded. Check the full eligibility rules before participating.

Resource Highlight

Resource	Why Check It Out
Deep Dive into LLMs like ChatGPT	A free 3+ hour deep dive by Andrej Karpathy covering how LLMs work, from tokenization and neural network internals to training, inference, hallucinations, tool use, and reinforcement learning.

📝 A quick note: I spend a lot of time researching and verifying every opportunity before featuring it in Dev Opportunity Radar. However, deadlines, eligibility, program details, and application requirements can change after publication. Before applying, please take a few minutes to visit the official program page, review the latest information, and confirm that you're eligible.

🔄 Still Open From Previous Editions

Before we get into this week's opportunities, here are a few from the previous two editions that are still accepting applications.

Since this is already Edition #14, the list of opportunities covered across the earlier editions is starting to get quite long. I used to keep all the still-open opportunities here, but I don't think repeating the full list every week makes the editions easier to read.

So from this edition onward, I'll keep this section to the two most recent editions. This way, you can still get a quick reminder about recent opportunities without making the weekly edition too long.

If you're looking for opportunities from earlier editions, they're still available on the Dev Opportunity Radar website, where you can browse the full list and use the filters to find what you're looking for.

I've already covered the opportunities below in detail, so I won't repeat everything here. If any of them catch your attention, you can find the full overview, eligibility details, and application links in the original edition.

Opportunity	Organization	Type	Format	Deadline	Featured In
Magnificent Grants	Magnificent Grants	Grant & Fellowship	Hybrid	Rolling	Edition #12
AI Societal Impact Lab Autumn 2026 Fellowship	AI Societal Impact Lab	Fellowship	Remote	September 4	Edition #12
a16z Alpha Fellowship	a16z speedrun × EO Ventures	Fellowship	In Person	September 2026	Edition #13
RevenueCat Shipaton 2026	RevenueCat	Hackathon	Online	October 1	Edition #13
Kaggriculture AI Agent Competition	Kaggle	AI Competition	Online	September 30	Edition #13

📍 This Week's Opportunities

Here are a few opportunities I came across this week that I thought were worth sharing.

📌 Razorpay AI Buildathon

Who it's for: Students interested in AI and software engineering who are able to work in person in Bangalore from September 2026.

What stands out: The Razorpay AI Buildathon is a student-only program where you build an AI project and use that project to apply for a 6 or 12-month AI Builder Internship at Razorpay.

There are five tracks you can choose from: AI Growth & Agentic Commerce, AI Risk Manager, AI Revenue Recovery, AI Finance Controller, and an Open Track if you want to build something outside the listed ideas.

I wanted to include this because I don't come across many opportunities where the project you build is actually part of the hiring process. Here, Razorpay is looking at how you think, what you build, how well it works, and even how you deal with things when they break.

Another thing I liked is that they don't make the application all about your resume. You'll need to submit a public GitHub repository, a five-minute pitch video, explain what your project solves, and talk about what broke and how you fixed it. There is also no aptitude test or group discussion. Shortlisted builders go directly to a panel.

The internship itself is also quite substantial. Selected students can choose between 6 or 12 months and receive a ₹75,000 monthly stipend while working in person in Bangalore.

I know many people reading the radar are looking for opportunities that are accessible globally, so this one is definitely more location-specific. I'm still sharing it because I think the combination of building something real + getting evaluated on your work + potentially turning that into a paid AI engineering internship makes this worth knowing about, especially for students in India who can be in Bangalore.

Internship: 6 or 12 months | Stipend: ₹75,000/month

Format: In person, Bangalore

Application Deadline: September 5, 2026

Application Requirements: Resume, project details, public GitHub repository, five-minute pitch video, and application questions.

🔗 Learn More & Apply

📌 Agents for Humans Hackathon

Who it's for: Developers, students, and builders who want to build an AI agent that can handle repetitive tasks for people. You can participate solo or with a team, and the hackathon is open to participants from around the world, with some countries and territories excluded.

What stands out: The Agents for Humans Hackathon, organized by AWS, is a six-week online hackathon where you build a new AI agent using the Strands Agents SDK. The idea is pretty simple: build something that can take care of a real task that people normally have to do themselves.

There are three tracks to choose from: Everyday Agents, for things like home, money, errands, or family tasks; Professional Agents, for repetitive work tasks; and Good Neighbor Agents, for agents that help groups such as nonprofits, schools, libraries, or local organizations.

I wanted to include this because I think the theme leaves quite a lot of room to build something you would actually want to use. You're not given one specific problem to solve, so you can start with a repetitive task you've personally dealt with and think about whether an agent could handle it.

Another thing I like is that the submission isn't just about showing an idea. You need to build a working agent, make your code publicly available, include an architecture diagram, and record a short demo showing it working. So if you're looking for a project that can also become something useful for your portfolio, this could be an interesting one to try.

The hackathon also provides $50 in AWS credits to help with build costs, and there is a total of $40,000 in cash prizes across the three tracks.

Prize Pool: $40,000

Format: Online | Build Period: Six weeks

Submission Deadline: September 15, 2026

Team Size: Solo or teams

What you need to build: A new AI agent using the Strands Agents SDK that handles a real, repetitive task.

Tracks: Everyday Agents, Professional Agents, and Good Neighbor Agents.

Additional Support: $50 in AWS credits are available for the build.

🔗 Learn More & Join the Hackathon

📌 MLH Global Hack Week: Data

Who it's for: Students, developers, and anyone interested in learning more about data, whether you're just getting started or already have some experience.

What stands out: Global Hack Week: Data is a free, week-long online event from Major League Hacking (MLH) where you can learn, build projects, complete challenges, and meet other people from the MLH community.

The week includes live workshops and technical challenges covering topics like SQL, databases, and data visualization. There are also smaller community events on Discord where you can meet other participants, work together, and take a break between challenges.

I wanted to include this because sometimes learning data skills can feel like you need to take a full course before you can actually start building something. This is a more relaxed way to spend a week exploring the area, learning something new, and actually putting it into practice.

Another thing I like is that you don't have to complete every challenge or already know what you're doing. Some challenges are simple, like connecting with other members of the community, while others involve building projects and creating demos. You can choose what you want to take on depending on your interests and experience.

And this one is actually global. It's completely free and open to participants from anywhere in the world, which is always something I look for when going through opportunities for the radar.

Event: September 11–17, 2026

Format: Fully online | Cost: Free

Topics: SQL, databases, data visualization, and other data-related technical skills.

🔗 Learn More & Register

📚 Resources Worth Checking Out

Not every useful find comes with an application deadline.

Here's one resource worth checking out this week.

Deep Dive into LLMs like ChatGPT

Who it's for: Developers, students, AI enthusiasts, and anyone who wants to understand how large language models like ChatGPT actually work. You don't need to be an AI researcher to follow it, but some basic technical knowledge will make it easier to get through the deeper sections.

What stands out: This is a free 3+ hour deep dive into LLMs by Andrej Karpathy, covering much more than just how to use ChatGPT. He walks through the full training stack, starting with internet data and tokenization, then moving into neural network internals, inference, pretraining, post-training, hallucinations, tool use, reinforcement learning, and how models actually "think."

I wanted to include this because there are so many resources about using AI tools, but fewer that actually help you understand what's happening underneath. If you've ever wondered how a large language model goes from a huge amount of text to something that can answer questions, write code, or use tools, this is a really good place to start.

Another thing I liked is that Karpathy doesn't only explain the technical side. He also talks about some of the strange ways LLMs behave, including hallucinations, tokenization problems, "jagged intelligence," knowledge and working memory, and why models can be surprisingly good at some things while struggling with others. That makes the video useful even if you're more interested in building with AI than training models yourself.

Format: Free recorded video | Length: Approximately 3 hours 22 minutes

Level: Beginner-friendly, with deeper technical sections

Topics Covered: LLM pretraining, tokenization, neural networks, inference, post-training, hallucinations, tool use, reinforcement learning, RLHF, DeepSeek-R1, and practical use of LLMs.

🔗 Watch the Video

🌟 Community Finds

One of my favorite things about this series has been seeing people share opportunities, communities, and resources that others might not have discovered otherwise.

We've had some really wonderful community finds over the last few weeks, and I honestly can't thank everyone enough for taking the time to find these opportunities, look through them, and send them my way. I know that takes time, and I appreciate every person who thinks of the Radar when they come across something they feel others might find useful 💙

This week, we weren't able to include a community find, but that's completely okay. Hopefully we'll have more wonderful finds from the community as we keep going.

So if you come across an opportunity, fellowship, grant, hackathon, conference, community, resource, or anything else you think more people should know about, please do send it my way. I love seeing what you find, and it helps make this series better for everyone.

If I feature something you shared in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

One small request: If you're sharing an opportunity, please avoid posting raw URLs directly in the comments. DEV sometimes filters them before I get a chance to see them.

A short description alongside the link makes it much easier for me to review and potentially feature it in a future edition.

💙 Reader Updates

I'm looking forward to this section gradually growing over time, and I'd still love to hear from you.

One of my favorite parts of writing Dev Opportunity Radar has been hearing from people who discovered something they otherwise might have missed.

You don't need to have been accepted or have a big success story to share. Sometimes simply discovering the right opportunity at the right time is already a win.

I hope this section gradually becomes a place where we can celebrate those stories together, one update at a time.

💙 A Little Personal Note

I know I've been a little quieter around the community over the last couple of weeks. I haven't been as active as I normally am, and I know I haven't been able to support everyone's posts and work in the same way I usually would.

I've been going through a difficult phase personally, with some things happening in my family, and I've needed to take a little step back. I haven't really talked about it here because I didn't quite know how to put it into words. But I wanted to share a little bit of it because so many of you have continued to support me and the Radar.

I'm sharing this here mainly because I don't want my being quiet to be misunderstood. This community means a lot to me, and I know many of you regularly support what I share. I don't want someone to think that I saw their work and chose not to support it, or that I don't care, when that isn't the case.

Even though I've been quieter, I'm still trying to keep up with everyone. Whenever I come online, especially when I'm working on the Radar on Fridays or whenever I have the energy during the week, I try to go through the posts and see what everyone has been working on. I may not always have the energy to leave a comment or reaction on everything, but I am still looking, reading, and cheering for you from my side.

So please don't take it personally if I haven't reacted to or commented on something you've shared. If I missed your post, there's a very good chance I simply missed it, not that I don't care about what you're doing. I know I may have missed quite a few things recently, and I'm genuinely sorry for that.

I also know that many of you continue to give me so much support, and I wish I could always give the same energy back. Right now, I just can't always be as present as I'd like to be. I'm doing what I can with what I have, and I hope you'll understand that.

I don't want this difficult phase to stop me from doing the things I care about either. The Radar is one of those things. Even if I'm somewhat quiet around the community for a while, I'll keep coming back every Friday with a new edition and keep doing my best to find and share opportunities that might help someone.

Thank you to everyone who has continued to support me, encourage me, read the editions, share opportunities, leave comments, and simply be here. I notice it, even when I don't always have the energy to respond properly. It means a lot to me 💙

And if I've missed your post recently, please know that I haven't stopped caring. I might have just missed it. I hope you guys understand.

👋 Until Next Friday

Before I go, I just want to say thank you.

The goal has always been simple:

Help people discover opportunities they otherwise might have missed.

Thanks to all of you, it feels like we're doing exactly that.

Thank you for reading, for sharing, and for helping make this our radar, not just mine.

I'll be back next Friday with more opportunities, resources, and Community Finds.

Until then, take care, and I hope you discover something amazing this week 💙

🌐 Dev Opportunity Radar Website

👉 Website

I also wrote a short post about why I built the website and the journey behind it.

👉 Website Launch Post

Dev Opportunity Radar #13: a16z Alpha, a $740K Hackathon, and an AI Agent Competition

Hemapriya Kanagala — Fri, 21 Aug 2026 17:06:59 +0000

TL;DR

Welcome back to Dev Opportunity Radar.

This is a weekly series where I share opportunities, resources, communities, and interesting finds that I come across, with the goal of helping people discover things they might otherwise miss.

This week's edition features the a16z Alpha Fellowship, RevenueCat Shipaton 2026, and the Kaggriculture AI Agent Competition, along with IBM SkillsBuild as a resource worth checking out.

If you're new to the series, you can also browse previous editions, search past opportunities, and explore Community Finds, Reader Updates, and Resources Worth Checking Out on the Dev Opportunity Radar website. I've also written a short post about why I built it. You'll find links to both at the end of this article.

This week's 🌟 Community Finds section features an opportunity shared by Konark Sharma (@konark_13). Thank you, Konark, for sharing the Agent Harness Hackathon. I always enjoy seeing readers help others discover opportunities they might otherwise have missed, and I hope this section continues to grow.

If you've discovered something through the radar, I'd love to hear about it. Whether you applied to an opportunity, attended an event, joined a community, completed a program, built something, or found a resource you hadn't seen before, I'd be happy to feature your experience in a future 💙 Reader Updates section (with your permission).

And if you've come across an opportunity, resource, community, program, event, or anything else you think deserves more attention, feel free to share it in the comments.

If I feature one of your 🌟 Community Finds in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

⚡ Quick Scan
🔄 Still Open From Previous Editions
📍 This Week's Opportunities
- 📌 a16z Alpha Fellowship
- 📌 RevenueCat Shipaton 2026
- 📌 Kaggriculture AI Agent Competition
📚 Resources Worth Checking Out
- IBM SkillsBuild
🌟 Community Finds
- The Agent Harness Hackathon
💙 Reader Updates
👋 Until Next Friday
🌐 Dev Opportunity Radar Website

⚡ Quick Scan

Opportunities

Opportunity	Organization	Type	Location / Format	Deadline
a16z Alpha Fellowship	a16z speedrun × EO Ventures	Fellowship	In Person (United States)	September 2026
RevenueCat Shipaton 2026	RevenueCat	Global Hackathon	Online (Global)	October 1
Kaggriculture AI Agent Competition	Kaggle	AI Competition	Online (Global)	September 30

Resource Highlight

Resource	Why Check It Out
IBM SkillsBuild	A free online learning platform offering courses and learning pathways across AI, cybersecurity, data, cloud, and other technology skills, with learning available in 20+ languages.

Community Finds

Shared By	Find	Type	Location / Format
Konark Sharma (@konark_13)	The Agent Harness Hackathon	AI Hackathon	Online (Global) / In Person (San Francisco)

📝 A quick note: I spend a lot of time researching and verifying every opportunity before featuring it in Dev Opportunity Radar. However, deadlines, eligibility, program details, and application requirements can change after publication. Before applying, please take a few minutes to visit the official program page, review the latest information, and confirm that you're eligible.

🔄 Still Open From Previous Editions

Before we get into this week's opportunities, here are a few from previous editions that are still accepting applications.

I've already covered these in detail, so I won't repeat everything here. If any of them catch your attention, you can find the full overview, eligibility details, and application links in the original edition.

Opportunity	Organization	Type	Format	Deadline	Featured In
FR8	FR8	Builder Residency	In Person	Rolling	Edition #2
Anthropic Fellows Program	Anthropic	AI Research Fellowship	In Person	Rolling	Edition #4
Sentient Open Source AGI Grant Program	Sentient Foundation	AI Grant & Investment	Remote	Rolling	Edition #6
Solo Grants	Solo Grants	Microgrant for Solo Builders	Remote	Rolling	Edition #7
Claude for Open Source	Anthropic	Open Source Program	Remote	Rolling	Edition #7
The Bridge	Entrepreneurs First	Founder Residency	In Person	August 30	Edition #9
Develop for Good Winter 2027	Develop for Good	Student Volunteer Program	Remote	August 31	Edition #10
Claude Community Ambassadors	Anthropic	Community Ambassador Program	Hybrid (Local Events)	Rolling	Edition #11
Z Fellows	Z Fellows	Founder Fellowship	Hybrid	Rolling	Edition #11
Magnificent Grants	Magnificent Grants	Grant & Fellowship	Hybrid	Rolling	Edition #12
AI Societal Impact Lab Autumn 2026 Fellowship	AI Societal Impact Lab	Fellowship	Remote	September 4	Edition #12
CodePath Fall 2026 Courses	CodePath	Technical Education Program	Virtual	August 23	Edition #12

📍 This Week's Opportunities

Here are a few opportunities I came across this week that I thought were worth sharing.

📌 a16z Alpha Fellowship

Who it's for: Technical students and recent graduates, generally within three years of graduating, who want to work at a fast-growing startup or try building their own company.

What stands out: The Alpha Fellowship gives you two options. You can join a fast-growing a16z portfolio company as a full-time software engineer, or you can apply through the Founder Track and get $20,000 in equity-free funding to start building your own company. The Founder Track can also lead to up to $250,000 in additional investment.

I wanted to include this because it's a pretty unusual opportunity for someone early in their career. You're not just getting another fellowship or a short course. You can either get a full-time engineering role at a growing startup or get funding to try building something yourself.

Another thing I like is that you don't need to already have a company or a complete team for the Founder Track. You apply as an individual, and if you already know who you want to build with, each person can apply separately and mention the others.

The fellowship itself is also very hands-on. It runs for eight weeks in person and includes a kickoff retreat, founder AMAs, small-group dinners, and access to the a16z speedrun community and events.

One important thing to know is that this is not globally accessible. You need valid U.S. authorization to work full time, and accepted fellows need to relocate for the in-person fellowship. I know I usually try to share opportunities that are accessible to people from different parts of the world, but I still wanted to include this one because the opportunity itself is too interesting to leave out. If you're eligible, definitely take a look.

Startup Track: Full-time software engineering role with salary and equity

Founder Track: $20,000 equity-free grant + up to $250,000 in additional investment

Fellowship: 8 weeks, in person

Who can apply: Technical students and recent graduates, generally within 3 years of graduation

Important: U.S. full-time work authorization is required.

Applications: Cohort 2 applications open in September 2026. Early applicants can submit now for priority consideration.

💡 Tip: You can apply to both tracks. If you're already building with a team, each person should apply separately and mention the other team members.

🔗 Learn More

📌 RevenueCat Shipaton 2026

Who it's for: Developers, students, indie builders, and teams who want to build and launch a mobile app.

What stands out: The RevenueCat Shipaton 2026 is a global online hackathon where the goal isn't just to build something. You actually have to launch a new app during the competition and use RevenueCat for monetization.

And the prize pool is pretty big. There is more than $740,000 in cash prizes, along with things like a Times Square billboard, media coverage, and a chance to attend RevenueCat's App Growth Annual conference in New York.

I wanted to include this because I like hackathons where you actually have to ship something people can use. Instead of building a prototype and stopping there, Shipaton gives you a reason to take the idea all the way to launch.

Another thing I like is that there are a lot of different categories, so you don't necessarily have to compete only for the main prize. There are awards for things like design, gaming, social good, growth, building in public, monetization, and a student-only Next Gen Award.

There are also sponsor prizes from companies like JetBrains, OneSignal, Replit, Samsung, Stripe, and others.

Prize Pool: $740,000+ | Format: Online, global hackathon

Build Window: August 1 – September 30, 2026 | Submission Deadline: October 1, 2026

Team: Individual or team participation

Who can participate: Ages 13–99, with some countries and territories excluded.

Main Requirement: Build and publicly launch a new app during the Shipaton window and integrate RevenueCat for monetization.

🔗 Learn More & Join the Hackathon

📌 Kaggriculture AI Agent Competition

Who it's for: Developers, students, AI engineers, machine learning practitioners, and anyone interested in experimenting with AI agents. Some Python experience will be helpful.

What stands out: Kaggriculture is a Kaggle competition where you build an AI agent that manages a virtual farm and competes against other agents on a live leaderboard.

Your agent has to make decisions over hundreds of turns, balancing things like farming, trading, expansion, resources, and changing market conditions to try to make the most profit.

I wanted to include this because it's very different from the Kaggle competitions you usually see. You're not just given a dataset and asked to build the best prediction model. You're actually building an agent that has to make decisions, plan ahead, and react to what is happening around it.

Another thing I like is that it gives you a way to experiment with agent design without needing to build a huge project from scratch. You're working inside a game-like environment, but you're still thinking about things like strategy, optimization, resource management, and planning.

And honestly, the farming part just makes it more fun than another competition where you're staring at a dataset all day.

Prize Pool: $50,000 USD ($5,000 each for the top 10 teams)

Format: Online Kaggle competition

Competition Start: July 29, 2026 | Entry Deadline: September 23, 2026

Final Submission Deadline: September 30, 2026

Team Size: Individual or team

🔗 Learn More & Join

📚 Resources Worth Checking Out

Not every useful find comes with an application deadline.

Here's one resource worth checking out this week.

IBM SkillsBuild

Who it's for: Students, recent graduates, and anyone who wants to build skills in areas like AI, cybersecurity, data, cloud, and other emerging technologies.

What stands out: IBM SkillsBuild is a free online learning platform with courses, learning pathways, hands-on learning, and digital credentials.

I wanted to include this because it's one of those resources that's worth bookmarking. If you're trying to learn something new alongside school, work, or a job search, there are a lot of different topics you can explore without paying for another course.

You can find content on things like generative AI, AI ethics, cybersecurity, data, cloud computing, and quantum computing, so there's a good amount to explore depending on what you're interested in.

Another thing I like is that it isn't just video courses. There are also hands-on labs, learning pathways, digital credentials, and virtual events.

Cost: Free | Format: Online | Languages: 20+ languages

Topics: AI, Generative AI, Cybersecurity, Data, Cloud, Quantum Computing, and more

Credentials: Digital credentials are available for selected activities and pathways.

🔗 Explore IBM SkillsBuild

🌟 Community Finds

One of my favorite things about this series has been seeing people share opportunities, communities, and resources that others might not have discovered otherwise.

The Agent Harness Hackathon

Shared by Konark Sharma (@konark_13).

Konark shared the Agent Harness Hackathon, a seven-day online hackathon from WeMakeDevs in collaboration with TrueFoundry.

The challenge is to build an AI agent using TrueForge, TrueFoundry's open-source agent harness. The idea is to build an agent that can actually take actions, connect to real tools, safely run generated code, and ask for human approval before doing something irreversible.

I wanted to include this because I like that it's focused on building agents that can actually do things, rather than just answering questions. You can build something like a code review agent, incident responder, research assistant, analytics agent, or come up with your own idea.

There are several categories to compete in, including Best Use of TrueForge, Best Code Quality, and Best UI. There are also prizes for the best blog and social posts.

The total prize pool is $10,000, including an NVIDIA DGX Spark, Mac Mini, iPad, and other prizes.

Format: Online, with an optional in-person event in San Francisco

Dates: August 24–30, 2026

Team Size: Solo or teams of up to 4

Prize Pool: $10,000

Submission Deadline: August 30, 2026 at 8:00 PM London time

Who can participate: Developers, students, builders, and anyone interested in AI agents.

🔗 Learn More & Register

Thank you to Konark Sharma (@konark_13) for thinking of the radar and sharing this with the community. It really means a lot 💙

I'd love for this section to keep growing.

If you've come across an opportunity, fellowship, grant, hackathon, conference, community, resource, or anything else you think more people should know about, feel free to share it in the comments.

If I feature it in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

One small request: If you're sharing an opportunity, please avoid posting raw URLs directly in the comments. DEV sometimes filters them before I get a chance to see them.

A short description alongside the link makes it much easier for me to review and potentially feature it in a future edition.

💙 Reader Updates

I'm looking forward to this section gradually growing over time, and I'd still love to hear from you.

One of my favorite parts of writing Dev Opportunity Radar has been hearing from people who discovered something they otherwise might have missed.

You don't need to have been accepted or have a big success story to share. Sometimes simply discovering the right opportunity at the right time is already a win.

I hope this section gradually becomes a place where we can celebrate those stories together, one update at a time.

👋 Until Next Friday

Before I go, I just want to say thank you.

The goal has always been simple:

Help people discover opportunities they otherwise might have missed.

Thanks to all of you, it feels like we're doing exactly that.

Thank you for reading, for sharing, and for helping make this our radar, not just mine.

I'll be back next Friday with more opportunities, resources, and Community Finds.

Until then, take care, and I hope you discover something amazing this week 💙

🌐 Dev Opportunity Radar Website

👉 Website

I also wrote a short post about why I built the website and the journey behind it.

👉 Website Launch Post

Transparency note: I used AI (Gemini) to create the banner image for this article.

I also used AI to help with grammar and wording. English isn't my first language, and sometimes I know exactly what I want to say but struggle to find the right words. I used AI to help me express those thoughts more clearly, especially when explaining opportunities and making sure the information was easy to follow.

The research, ideas, experiences, perspectives, and decisions about what to include are my own. As always, I recommend checking the official links before applying, since deadlines and program details can change.

Dev Opportunity Radar #12: $10K+ Magnificent Grants, Free CodePath Courses, AI Societal Impact Lab Fellowship, and Interview Prep 101

Hemapriya Kanagala — Fri, 14 Aug 2026 17:48:56 +0000

TL;DR

Welcome back to Dev Opportunity Radar.

This is a weekly series where I share opportunities, resources, communities, and interesting finds that I come across, with the goal of helping people discover things they might otherwise miss.

This week's edition features Magnificent Grants, the AI Societal Impact Lab Autumn 2026 Fellowship, CodePath's Fall 2026 Courses, and Interview Prep 101, a free workshop recording from CodePath's Emerging Engineers Summit packed with practical advice for technical interviews.

If you're new to the series, you can also browse previous editions, search past opportunities, and explore Community Finds, Reader Updates, and Resources Worth Checking Out on the Dev Opportunity Radar website. I've also written a short post about why I built it. You'll find links to both at the end of this article.

This week's 🌟 Community Finds section features an opportunity shared by Konark Sharma (@konark_13). Thank you, Konark, for recommending the Zero Downtime Hackathon. I always enjoy seeing readers help others discover opportunities they might otherwise have missed, and I hope this section continues to grow.

If you've discovered something through the radar, I'd love to hear about it. Whether you applied to an opportunity, attended an event, joined a community, completed a program, built something, or found a resource you hadn't seen before, I'd be happy to feature your experience in a future 💙 Reader Updates section (with your permission).

And if you've come across an opportunity, resource, community, program, event, or anything else you think deserves more attention, feel free to share it in the comments.

If I feature one of your 🌟 Community Finds in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

⚡ Quick Scan
🔄 Still Open From Previous Editions
📍 This Week's Opportunities
- 📌 Magnificent Grants
- 📌 AI Societal Impact Lab Autumn 2026 Fellowship
- 📌 CodePath Fall 2026 Courses
📚 Resources Worth Checking Out
- CodePath: Interview Prep 101
🌟 Community Finds
- Zero Downtime Hackathon
💙 Reader Updates
👋 Until Next Friday
🌐 Dev Opportunity Radar Website

⚡ Quick Scan

Opportunities

Opportunity	Organization	Type	Format	Deadline
Magnificent Grants	Magnificent Grants	Grant & Fellowship	Hybrid	Rolling
AI Societal Impact Lab Autumn 2026 Fellowship	AI Societal Impact Lab	Fellowship	Remote	September 4
CodePath Fall 2026 Courses	CodePath	Technical Education Program	Virtual	August 23

Resource Highlight

Resource	Why Check It Out
CodePath: Interview Prep 101	A free workshop recording covering practical interview strategies, communication, structuring answers, and techniques to help you perform more confidently in technical interviews.

Community Finds

Shared By	Find	Type	Format
Konark Sharma (@konark_13)	Zero Downtime Hackathon	AI Hackathon	In Person (San Francisco)

📝 A quick note: I spend a lot of time researching and verifying every opportunity before featuring it in Dev Opportunity Radar. However, deadlines, eligibility, program details, and application requirements can change after publication. Before applying, please take a few minutes to visit the official program page, review the latest information, and confirm that you're eligible.

🔄 Still Open From Previous Editions

Before we get into this week's opportunities, here are a few from previous editions that are still accepting applications.

Opportunity	Organization	Type	Format	Deadline	Featured In
FR8	FR8	Builder Residency	In Person	Rolling	Edition #2
Anthropic Fellows Program	Anthropic	AI Research Fellowship	In Person	Rolling	Edition #4
Sentient Open Source AGI Grant Program	Sentient Foundation	AI Grant & Investment	Remote	Rolling	Edition #6
Solo Grants	Solo Grants	Microgrant for Solo Builders	Remote	Rolling	Edition #7
Claude for Open Source	Anthropic	Open Source Program	Remote	Rolling	Edition #7
AIAF Fellowship 2026	AIAF × AE Studio	AI Research Fellowship	Remote	August 17	Edition #8
The Bridge	Entrepreneurs First	Founder Residency	In Person	August 30	Edition #9
Develop for Good Winter 2027	Develop for Good	Student Volunteer Program	Remote	August 31	Edition #10
Claude Community Ambassadors	Anthropic	Community Ambassador Program	Hybrid (Local Events)	Rolling	Edition #11
Z Fellows	Z Fellows	Founder Fellowship	Hybrid	Rolling	Edition #11

📍 This Week's Opportunities

Here are a few opportunities I came across this week that I thought were worth sharing.

📌 Magnificent Grants

Who it's for: Builders, founders, researchers, creators, and ambitious young people aged 25 or younger who are working on ambitious ideas, side projects, startups, or other high-impact work. You don't need to have a company or drop out of school to apply, although showing meaningful progress on what you're building will strengthen your application.

What stands out: Magnificent Grants awards $10,000+ grants to a small group of young builders each year, along with two years of mentorship from experienced founders and investors. Unlike many startup programs, the grant comes with no equity requirement, allowing recipients to continue building independently while receiving ongoing support.

I wanted to include this because it's refreshing to see a program that's willing to support people at a very early stage. Many fellowships expect applicants to already have traction, funding, or a well-established company. Here, the focus seems to be on identifying exceptional people with ambitious ideas and helping them move faster.

Another thing I like is that the support extends well beyond the grant itself. Fellows become part of a two-year community where they receive mentorship, meet other grantees, and continue building relationships with experienced founders and investors. The fact that you don't need to drop out of school or leave your job also makes it accessible to more people who are still exploring their ideas.

Grant: $10,000+ (no equity required)

Program Duration: Two years

Who can apply: Anyone aged 25 or younger from anywhere in the world.

Application Deadline: Rolling

🔗 Learn More | 🔗 Apply

📌 AI Societal Impact Lab Autumn 2026 Fellowship

Who it's for: Recent graduates, early-career researchers, and people interested in exploring how AI is shaping society. While the fellowship is primarily aimed at applicants from the social sciences and humanities, people from STEM, the arts, and other backgrounds are also encouraged to apply. Previous AI experience is welcome but not required.

What stands out: The AI Societal Impact Lab Autumn 2026 Fellowship is a remote 8 to 10-week program that brings together people interested in the societal and political implications of AI. Fellows participate in weekly discussions, receive mentorship, work on a collaborative group project, attend workshops and seminars, and write their own analytical piece that will be published on the AI Societal Impact Lab website.

I wanted to include this because most AI fellowships focus on building models or developing technical skills. This one takes a different approach by exploring the broader questions around how AI is changing society and encouraging thoughtful discussions from people with different backgrounds.

Another thing I like is that you don't need to be an AI expert to apply. The fellowship welcomes people from a variety of disciplines and creates a space where different perspectives can come together. If you've been curious about AI governance, ethics, public policy, or the social impact of emerging technologies, this looks like a great place to learn and contribute.

Program Duration: Approximately 8 to 10 weeks (starting in mid to late September 2026)

Time Commitment: Around 4 hours per week

Format: Fully remote

Benefits: Mentorship, workshops and seminars, collaborative group project, publication on the AI Societal Impact Lab website, and a community of fellows.

Who can apply: Recent graduates, early-career researchers, and applicants from a wide range of backgrounds, including humanities, social sciences, STEM, and the arts.

Application Deadline: September 4, 2026 (rolling until filled)

🔗 Learn More | 🔗 Apply

📌 CodePath Fall 2026 Courses

Who it's for: Students and recent graduates in computer science or software-related programs who want to strengthen their technical skills, prepare for internships and full-time roles, and learn in a structured, instructor-led environment. Some pathways have additional prerequisites, so be sure to review the requirements before applying.

What stands out: CodePath is offering its Fall 2026 cohort of free, instructor-led technical courses in Applied AI Engineering, Technical Interview Prep, Cybersecurity, and Web Development. Each pathway runs virtually for around 10 weeks, combining live classes, hands-on assignments, projects, and mentorship from engineers at leading technology companies.

I wanted to include this because I've personally completed two CodePath courses: Intermediate Cybersecurity (with Honors) and Intro to Technical Interview Prep. They were genuinely some of the most valuable learning experiences I've had. The courses aren't passive video lectures. Every week includes live, interactive sessions, breakout discussions with peers and teaching assistants, and practical assignments that push you to apply what you've learned.

One thing I also appreciate is that CodePath expects commitment. Getting accepted isn't the final step. Every applicant is required to complete pre-work as part of the admissions process, and it takes real time and effort. It's one of the reasons the community stays so engaged. Everyone begins the course having already demonstrated they're willing to put in the work.

Another thing I like is that the experience continues well beyond the classroom. After completing a course, students gain access to career services, a large network of students and alumni, industry mentors, recruiting events, career fairs, workshops with leading technology companies, and an active Slack community where people continue learning and helping one another.

Available Pathways:

Applied AI Engineering
Technical Interview Prep
Cybersecurity
Web Development

Duration: Approximately 10 weeks

Format: Virtual, instructor-led

Cost: Free

Who can apply: Students aged 18+ who will be enrolled in a U.S. college or university during Fall 2026 in a computer science or software-related degree program. WEB101 and CYB101 are open to students from all majors. Recent computer science graduates are also eligible. Individual courses may have additional prerequisites.

Application Deadline: August 23, 2026

💡 Tip: Don't wait until the last minute. After submitting your application, you'll need to complete the required pre-work before your application can be reviewed. The pre-work takes time, so applying early gives you the best chance of completing everything before the deadline.

🔗 Learn More & Apply

📚 Resources Worth Checking Out

Not every useful find comes with an application deadline.

Here's one resource worth checking out this week.

CodePath: Interview Prep 101 (Free Workshop Recording)

Who it's for: Students, new graduates, internship applicants, and anyone preparing for software engineering interviews.

What stands out: This free session from CodePath's 2024 Emerging Engineers Summit focuses on the parts of interviewing that people often overlook. Instead of diving straight into coding problems, it covers how to make a strong first impression, communicate your thought process, structure your answers, and approach technical interviews with more confidence.

I wanted to include this because interview preparation isn't just about solving LeetCode problems. Being able to clearly explain your thinking, communicate with your interviewer, and approach questions in a structured way can make a huge difference. I found this session practical and easy to follow, especially for people preparing for internships or new graduate roles.

Another thing I like is that it's only around an hour long, making it an easy resource to watch before interview season. If you're already practicing coding problems, this is a nice complement that focuses on the communication side of technical interviews.

Format: Free recorded workshop

Level: Beginner to Intermediate

Topics Covered: Technical interview preparation, communication, structuring answers, interview tips, and best practices.

🔗 Watch the Session

🌟 Community Finds

One of my favorite things about this series has been seeing people share opportunities, communities, and resources that others might not have discovered otherwise.

Zero Downtime Hackathon

Shared by Konark Sharma (@konark_13).

Konark shared the Zero Downtime Hackathon, and I thought it would be worth passing along for anyone interested in building AI applications.

The hackathon focuses on building resilient AI systems rather than just prototypes. Participants will use Port for project organization, Bright Data Scraper Studio for web data extraction, and SigNoz for observability to create an end-to-end application, pipeline, or AI agent. Projects will also be judged by engineers from Anthropic.

I wanted to feature this because it encourages participants to think beyond simply getting an AI application to work. It emphasizes planning, monitoring, and building systems that can continue running even when things change, which are skills that become increasingly important as AI projects move into production.

There are also some exciting prizes, including an NVIDIA DGX Spark AI Supercomputer for the overall winner, along with track prizes for the best integrations with each sponsor tool.

Who it's for: Developers, students, builders, and AI enthusiasts interested in building production-ready AI applications.

Format: In-person hackathon (San Francisco, California)

Event Date: August 22, 2026

Team Size: 1 to 4 participants

🔗 Learn More & Register

Thank you to Konark Sharma (@konark_13) for thinking of the radar and sharing this with the community. It really means a lot 💙

I'd love for this section to keep growing.

If you've come across an opportunity, fellowship, grant, hackathon, conference, community, resource, or anything else you think more people should know about, feel free to share it in the comments.

If I feature it in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

One small request: If you're sharing an opportunity, please avoid posting raw URLs directly in the comments. DEV sometimes filters them before I get a chance to see them.

A short description alongside the link makes it much easier for me to review and potentially feature it in a future edition.

💙 Reader Updates

I'm looking forward to this section gradually growing over time, and I'd still love to hear from you.

One of my favorite parts of writing Dev Opportunity Radar has been hearing from people who discovered something they otherwise might have missed.

You don't need to have been accepted or have a big success story to share. Sometimes simply discovering the right opportunity at the right time is already a win.

I hope this section gradually becomes a place where we can celebrate those stories together, one update at a time.

👋 Until Next Friday

Before I go, I just want to say thank you.

The goal has always been simple:

Help people discover opportunities they otherwise might have missed.

Thanks to all of you, it feels like we're doing exactly that.

Thank you for reading, for sharing, and for helping make this our radar, not just mine.

I'll be back next Friday with more opportunities, resources, and Community Finds.

Until then, take care, and I hope you discover something amazing this week 💙

🌐 Dev Opportunity Radar Website

👉 Website

I also wrote a short post about why I built the website and the journey behind it.

👉 Website Launch Post

What Would You Tell Someone Early in Their Career?

Hemapriya Kanagala — Mon, 10 Aug 2026 12:42:18 +0000

📌 TL;DR

I'm still early in my own career, and lately I've been thinking about how much advice we hear when we're starting out.

Learn this. Build that. Get certified. Network more. Specialize. Don't specialize too early. Work harder. Protect your work-life balance.

Sometimes it feels like everyone has an answer 😄

But careers are long, and I think some lessons only really make sense after you've lived through them.

That's what made me think about this community.

DEV has people at so many different stages of their careers, with completely different experiences. Some are just starting. Some have been working for a few years. Others have decades of experience. Some have changed careers entirely, managed teams, built companies, made mistakes, started over, burned out, found work they love, or discovered that what they thought they wanted wasn't actually right for them.

That's a lot of experience in one place.

So this post is a little different. I'll share some of what I'm learning while being early in my own career, but mostly, I want to listen to you.

What would you tell someone early in their career?

And there's no limit here 😄 If one thing comes to mind, share one. If you have five, ten, or a whole list of things experience has taught you, I'd genuinely love to hear them all. They don't have to be about the same topic either.

Talk about whatever you feel is worth passing on. It can be technical, personal, or somewhere in between: work, money, learning, managers, communication, confidence, health, work-life balance, mistakes, opportunities, relationships, or something completely different.

And if you're early in your career too, you're absolutely part of this conversation. Share something you've already learned, something you wish you'd known when you started, or something you're still trying to figure out.

And if you have a question, ask it. There might be someone here who's already been through exactly what you're wondering about and can share what they learned. And if it's something I happen to know or have experienced too, I'll be happy to share what I can.

My hope is that we can turn the comments into a place where people at different stages of their careers can ask questions, share experiences, and learn from each other 💙

📚 Table of Contents

This Post Is a Little Different
I'm Learning That There Probably Isn't One Correct Way to Build a Career
There's So Much About a Career That Doesn't Fit on a Resume
Some of You Have Already Lived the Years the Rest of Us Are Just Beginning
So... What Would You Tell Someone Early in Their Career?
It Doesn't Have to Be Career Advice in the Traditional Sense
Why I'm Asking the Community Instead of Writing an Advice Post
I Have a Feeling the Best Part of This Post Might Be the Comments

This Post Is a Little Different

I had a slightly different idea for this post.

Usually when I sit down to write something, I have a topic I want to explore, an experience I want to share, or, apparently lately, a technical report that sends me down a rabbit hole for several hours 😄

But this time, I want to write a little less and listen a little more.

I'm still early in my own career. There are things I understand much better today than I did a few years ago, but I'm also pretty sure there are things I'll look back on five or ten years from now and think, “I really wish I had understood that earlier.”

Maybe someone has already told me some of those things and I haven't had enough experience yet to understand why they matter. Or maybe they're lessons I'll only learn by going through something myself.

Either way, it made me think about something I really like about communities like DEV: we're all at completely different points in our careers.

Some people here are just figuring out what they want to do, while others have been working for years or even decades. And even within that, no two paths look exactly the same. People change fields, become managers, go back to being individual contributors, build companies, take career breaks, start over, or watch their carefully planned career go somewhere completely unexpected.

Every one of those paths comes with lessons.

And that's what made me wonder:

What could those of us who are early in our careers learn from everyone else's experiences?

I'm Learning That There Probably Isn't One Correct Way to Build a Career

When you're early in your career, it's surprisingly easy to feel like you're doing something wrong.

You look around and someone seems to be learning faster than you, someone else just got promoted, and another person landed an opportunity you'd love to have. Some people already seem to know exactly what they want to specialize in, while others have incredible portfolios or somehow sound completely confident about where their careers are going.

And meanwhile, you might still be sitting there thinking, “I don't even know exactly what I want to be doing three years from now” 😄

I've definitely spent time worrying about things like that myself. But I'm slowly realizing that careers probably aren't as linear as they sometimes look from the outside.

People change roles, discover that something they thought they'd love isn't actually for them, or become interested in something they never planned to pursue. They take breaks, make mistakes, change their minds, and sometimes start again. An opportunity that looks perfect might teach you what you don't want, while something that feels like a complete detour might end up being useful years later in a way you couldn't possibly have predicted at the time.

I think that's part of what makes comparing career paths so difficult. We usually see where someone is now, but we don't necessarily see all the changes, uncertainty, mistakes, and unexpected turns that happened along the way.

I'm still figuring out my own path, so I'm definitely not going to tell anyone exactly how they should build theirs. But one thing I'm trying to become more comfortable with is not having the entire map yet.

Maybe knowing where I want to go next is enough for now.

There's So Much About a Career That Doesn't Fit on a Resume

When we're starting out, a lot of our attention naturally goes toward the things we can show: the skills we're learning, projects we're building, certifications we're earning, our education, experience, and eventually the achievements we can point to.

And of course those things matter.

But the longer I think about careers, the more I wonder whether some of the lessons that shape them the most are things we'll never put on a resume.

Things like knowing when to ask for help instead of spending another five hours trying to solve something alone. Learning how to disagree with someone without turning that disagreement into a fight. Being able to say “I don't know” without immediately worrying that everyone will suddenly think you don't belong there.

Then there are decisions that don't always have an obvious right answer. How do you know whether an opportunity is genuinely good for you or just looks impressive from the outside? When should you negotiate, and when should you walk away? How do you deal with a bad manager, or eventually learn to become a good one yourself?

And some of the questions go beyond work itself. How much of your identity should your career take up? How do you stay ambitious without feeling like every free hour needs to become another opportunity to be productive? How do you take care of your health while still trying to build the future you want?

I don't think there's one course we can take that neatly teaches all of that.

A lot of it seems to come from living through things, making choices, getting some of them wrong, watching other people go through their own experiences, and slowly figuring out what matters to us along the way.

And that's exactly why I wanted to write this post.

Some of You Have Already Lived the Years the Rest of Us Are Just Beginning

That's something I think is pretty amazing when you really stop and think about it.

Someone reading this might be preparing for their very first interview, while someone else might be three years into their career. Another person might have fifteen or twenty years of experience, and someone else might have spent decades doing one thing only to eventually decide they wanted to start over in a completely different direction.

And all of that experience means much more than knowing different technologies or having different job titles.

People have worked with managers they loved and managers who taught them exactly what they wouldn't want to do if they ever became one themselves. They've made career decisions that worked out beautifully and others they probably wouldn't make again. They've negotiated salaries, accepted opportunities, turned others down, stayed somewhere too long, left somewhere too early, found mentors, and maybe eventually became mentors for someone else.

They've also had time to discover which worries actually mattered. Some of the things that felt incredibly important at the beginning of their careers might barely matter to them now, while things they hardly thought about back then may have turned out to matter much more than they expected.

And that's the kind of knowledge I'm curious about.

I'm not looking for another perfect career roadmap or a formula that says, “Do these seven things and you'll be successful.”

I'm much more interested in what people learned from actually going through it: the good decisions, the mistakes, the unexpected turns, and the things they understand now that they couldn't have understood when they were just beginning.

So... What Would You Tell Someone Early in Their Career?

This is the part where I hand the post over to you 😄

If you've been working for a while, I'd love for you to think back to the beginning of your career and everything you've experienced since then.

What do you know now that you wish you'd understood earlier? And what would you want someone early in their career to know?

Please don't feel like you have to choose just one thing either. You might have something to say about technical skills and something completely different to say about work-life balance. Your lessons might be about managers, communication, money, confidence, networking, changing jobs, burnout, asking for help, choosing opportunities, dealing with mistakes, knowing when to walk away, or something I haven't even thought to mention.

Maybe there's something you spent far too much time worrying about early on that you now realize wasn't nearly as important as it seemed. Or perhaps there's something you barely thought about at the beginning that you now wish you'd taken much more seriously.

And if your advice completely contradicts someone else's advice here, that's okay too. I'd actually love to see those different perspectives. What worked beautifully for one person might have been completely wrong for someone else.

You also don't need twenty years of experience to contribute. If you're early in your career too, you're just as much a part of this conversation. You might already have learned something from your first job, an opportunity you took, a mistake you made, a difficult experience, or simply something that's helped you along the way.

And if you feel like you're still figuring everything out, you don't need to have advice at all.

You can ask instead.

What do you wish you could ask someone further along in their career?

There might be someone reading this who remembers having exactly the same question and has already lived through the experience you're wondering about.

That's really what I'm hoping this discussion can become: not experienced people talking at people who are just beginning, but people at different stages of their careers learning from each other.

It Doesn't Have to Be Career Advice in the Traditional Sense

When we hear “career advice,” it's easy for the conversation to immediately become about what skill to learn next, which certification to get, or which technology to master.

And those conversations can absolutely be useful. But I think a career is much bigger than the technical skills required to do a job.

Maybe experience taught you to protect your weekends, start saving money earlier, ask more questions, find mentors, document your work, take your health seriously, make sure you have a life outside work, or stop comparing your entire career with the small part of someone else's life you see online.

Maybe it's something completely unexpected that I haven't even thought to mention.

Actually, those unexpected answers might be the ones I'm most curious to read.

Because sometimes the advice that stays with us isn't the advice we went looking for in the first place.

Why I'm Asking the Community Instead of Writing an Advice Post

I could have written an article called “Things You Should Know Early in Your Career.”

But that wouldn't feel quite right coming from me.

I'm early in my own career too. I have things I've learned so far and experiences that have changed how I think, but I also know there are situations I simply haven't lived through yet.

Instead of pretending otherwise, I'd rather ask people who have lived through them.

And experience doesn't only mean years worked.

Someone with twenty years of experience might share something that helps someone with two. Someone with two years might remember the uncertainty of starting out much more clearly. And someone entering the workforce today is experiencing things around AI, remote work, learning, and hiring that didn't exist in quite the same way ten or twenty years ago.

Different stages of a career teach us different things, and that's what makes this much more interesting to me than trying to write a career guide myself.

I Have a Feeling the Best Part of This Post Might Be the Comments

And honestly, that's what I'm hoping for 😄

I've had conversations here where someone left a comment that made me look at something completely differently, introduced me to an idea I hadn't considered, or brought years of experience to something I had only recently started thinking about.

That's one of my favorite things about writing in a community like DEV. You don't just publish something and walk away. Sometimes what you write starts a conversation, and that conversation ends up teaching you just as much as the article itself.

So maybe this post can become a little collection of experiences.

Not a definitive career guide.

Not a roadmap everyone is supposed to follow.

Just people at different stages of their lives and careers sharing what they've learned along the way.

Someone might come across a comment and think, “I really needed to hear that.” Someone else might discover an idea they hadn't considered before, or read a perspective that stays with them until they encounter that situation themselves.

And I fully expect to be taking notes too 😄

So I'll leave this one with all of you:

What would you tell someone early in their career?

Share as much or as little as you'd like. If you have one lesson, I'd love to hear it. If years of experience have given you five or ten things you wish you'd known earlier, please share those too.

And if you're early in your career too, I'd love to hear from you just as much. Tell us what you've already learned, what you're struggling with, or what you wish you could ask someone who's been where you are now.

There isn't one correct way to build a career, and I don't expect there to be one correct answer here either.

In fact, I think the different answers are what could make this discussion useful.

So, what has your career taught you that you'd pass on to someone who's still near the beginning? I'd really love to hear it 💙

Transparency note: The banner image for this article was generated using DEV Community's built-in AI image generation feature. I wrote the prompt, generated multiple variations, and selected the final image used in this post.

I also used AI to help check my grammar and make sure I was expressing my thoughts clearly. English isn't my first language, so sometimes I know what I want to say but need a little help making sure the wording comes across correctly. The ideas, experiences, and perspectives in this article are my own.

Dev Opportunity Radar #11: Claude Community Ambassadors, YC Startup Internship Expo, Z Fellows, and Stanford's AI Agents Course

Hemapriya Kanagala — Fri, 07 Aug 2026 15:52:30 +0000

TL;DR

Welcome back to Dev Opportunity Radar.

This is a weekly series where I share opportunities, resources, communities, and interesting finds that I come across, with the goal of helping people discover things they might otherwise miss.

This week's edition features the Claude Community Ambassadors Program, the YC Startup Internship Expo, Z Fellows, and CS329A: Self-Improving AI Agents, a free graduate-level Stanford course exploring the latest research behind modern AI agents.

If you're new to the series, you can also browse previous editions, search past opportunities, and explore Community Finds, Reader Updates, and Resources Worth Checking Out on the Dev Opportunity Radar website. I've also written a short post about why I built it. You'll find links to both at the end of this article.

This week's 🌟 Community Finds section features opportunities shared by Francis (@francistrdev) and Konark Sharma (@konark_13). I always love seeing readers help others discover opportunities they might otherwise have missed.

If you've discovered something through the radar, I'd love to hear about it. Whether you applied to an opportunity, attended an event, joined a community, completed a program, built something, or found a resource you hadn't seen before, I'd be happy to feature your experience in a future 💙 Reader Updates section (with your permission).

And if you've come across an opportunity, resource, community, program, event, or anything else you think deserves more attention, feel free to share it in the comments.

If I feature one of your 🌟 Community Finds in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

⚡ Quick Scan
🔄 Still Open From Previous Editions
📍 This Week's Opportunities
- 📌 Claude Community Ambassadors
- 📌 YC Startup Internship Expo
- 📌 Z Fellows
📚 Resources Worth Checking Out
- CS329A: Self-Improving AI Agents
🌟 Community Finds
- CALEC Volunteer and Internship Opportunities
- JPMorganChase Code for Good Singapore & Software Engineer Program
💙 Reader Updates
👋 Until Next Friday
🌐 Dev Opportunity Radar Website

⚡ Quick Scan

Opportunities

Opportunity	Organization	Type	Format	Deadline
Claude Community Ambassadors	Anthropic	Community Ambassador Program	Hybrid (Local Events)	Rolling
YC Startup Internship Expo	Y Combinator	Startup Career Expo	In Person (San Francisco)	August 15 (Event)
Z Fellows	Z Fellows	Founder Fellowship	Hybrid	Rolling

Resource Highlight

Resource	Why Check It Out
CS329A: Self-Improving AI Agents	A free graduate-level Stanford course covering modern AI agent research, including constitutional AI, tool use, planning, reinforcement learning, memory, and evaluation frameworks.

Community Finds

Shared By	Find	Type	Format
Francis (@francistrdev)	CALEC Volunteer & Internship Opportunities	Volunteer & Internship Opportunities	Remote
Konark Sharma (@konark_13)	JPMorganChase Code for Good Singapore & Software Engineer Program	Hackathon & Internship	In Person (Singapore)

📝 A quick note: I spend a lot of time researching and verifying every opportunity before featuring it in Dev Opportunity Radar. However, deadlines, eligibility, program details, and application requirements can change after publication. Before applying, please take a few minutes to visit the official program page, review the latest information, and confirm that you're eligible.

🔄 Still Open From Previous Editions

Before we get into this week's opportunities, here are a few from previous editions that are still accepting applications.

Opportunity	Organization	Type	Format	Deadline	Featured In
FR8	FR8	Builder Residency	In Person	Rolling	Edition #2
Anthropic Fellows Program	Anthropic	AI Research Fellowship	In Person	Rolling	Edition #4
Sentient Open Source AGI Grant Program	Sentient Foundation	AI Grant & Investment	Remote	Rolling	Edition #6
Solo Grants	Solo Grants	Microgrant for Solo Builders	Remote	Rolling	Edition #7
Claude for Open Source	Anthropic	Open Source Program	Remote	Rolling	Edition #7
AIAF Fellowship 2026	AIAF × AE Studio	AI Research Fellowship	Remote	August 17	Edition #8
The Bridge	Entrepreneurs First	Founder Residency	In Person	August 30	Edition #9
Develop for Good Winter 2027	Develop for Good	Student Volunteer Program	Remote	August 31	Edition #10
OpenAI Student Collective	OpenAI	Campus Leadership Program	In Person (Campus-Based)	August 10	Edition #10

📍 This Week's Opportunities

Here are a few opportunities I came across this week that I thought were worth sharing.

📌 Claude Community Ambassadors

Who it's for: Developers, community organizers, meetup hosts, technical educators, and active Claude users who enjoy bringing people together and helping others learn. You don't need to be a professional developer, but you should have meaningful experience using Claude and a track record of community involvement.

What stands out: The Claude Community Ambassadors program gives community builders the opportunity to grow local Claude communities with support from Anthropic. Ambassadors can host meetups, workshops, hackathons, and other community events while receiving event funding, monthly API credits, ready-to-use event materials, swag, and promotion through Anthropic's channels.

I wanted to include this because most ambassador programs are focused on students. This one is different. It's designed for people who are already active in their local tech communities or online communities and want to help others explore Claude while building a stronger local developer ecosystem.

Another thing I like is that the program goes beyond hosting events. Ambassadors get early access to selected features, opportunities to participate in Builders Council sessions, and a direct way to share feedback from their communities with Anthropic's product teams. If you enjoy teaching, organizing events, or building developer communities, this could be a great opportunity to make an impact while connecting with other community leaders around the world.

Program Duration: Ongoing

Cost: Free

Benefits: Event sponsorship, monthly Claude API credits, exclusive swag, access to a private Ambassador Slack, pre-release features, and opportunities to provide product feedback.

Who can apply: Community builders and experienced Claude users from anywhere in the world. Professional developer experience is not required.

Application Deadline: Rolling

🔗 Learn More | 🔗 Apply

📌 YC Startup Internship Expo

Who it's for: Students looking for internships, co-ops, semester internships, or new graduate roles who will be in the San Francisco Bay Area on August 15. YC is also encouraging applications from exceptional high school builders.

What stands out: The YC Startup Internship Expo is a one-day, acceptance-only event where students can meet founders, engineers, and hiring teams from 50+ Y Combinator startups. Rather than browsing job boards, attendees get the chance to explore what it's actually like to work at early-stage AI startups, participate in coding and AI challenges, network with startup teams, and even interview onsite with more than 40 YC companies.

I wanted to include this because opportunities like this don't come around very often. Instead of applying online and hoping someone sees your resume, you get to meet founders and engineers face-to-face, ask questions, and learn how some of today's fastest-growing AI startups actually build products.

Another thing I like is that it's more than just a career fair. Alongside the startup expo, there will be coding and AI challenges, giveaways, food trucks, and onsite interviews happening throughout the day. If you're already spending the summer in San Francisco or studying in the Bay Area, this could be a great opportunity to explore internships while connecting with people building at the forefront of AI.

Event Date: August 15, 2026

Location: San Francisco, California

Cost: Free (application required)

Who can apply: Students interning in San Francisco, students attending Bay Area colleges or universities, and exceptional high school builders who will be in the Bay Area on the event date.

Application Process: Acceptance only

Travel Support: No travel sponsorship is provided.

🔗 Learn More & Apply

📌 Z Fellows

Who it's for: Technical builders, aspiring founders, students, recent graduates, researchers, engineers, and anyone working on a side project or startup. You can apply solo or with a team, and you don't need to have a company yet.

What stands out: Z Fellows is a one-week founder program that brings together a small group of ambitious builders with founders and investors behind companies like Figma, Vercel, Instacart, Netflix, DoorDash, and AngelList. The week is designed to help early builders learn from experienced founders, connect with other ambitious people, and accelerate whatever they're working on. The support doesn't stop after the program. Z Fellows continues helping founders throughout their journey.

I wanted to include this because most startup programs expect you to already have a company, traction, or funding. Z Fellows takes a different approach. It's built for people who are still early and simply have the ambition to build something meaningful. Whether you're working on a side project, exploring an idea, or already building a startup, the focus is on backing people with potential before everyone else notices them.

Another thing I like is how flexible the program is. You don't need to quit your job, leave school, or even have a co-founder to apply. The program is mostly virtual, with the final day taking place in San Francisco or New York City, making it accessible to builders from around the world. Applicants can also choose to participate without funding or accept an optional $10,000 investment through a SAFE agreement if it makes sense for their company.

Program Duration: One week (multiple cohorts each year)

Format: Mostly virtual, with the final day held in San Francisco or New York City

Funding: Optional $10,000 investment through a SAFE agreement

Who can apply: Builders from anywhere in the world. No age restrictions. You can apply as an individual or as a team, and you don't need a company to get started.

Application Deadline: Rolling

🔗 Learn More | 🔗 Apply

📚 Resources Worth Checking Out

Not every useful find comes with an application deadline.

Here's one resource worth checking out this week.

CS329A: Self-Improving AI Agents

Who it's for: Developers, AI engineers, researchers, graduate students, and anyone who already has a basic understanding of large language models and wants to dive deeper into modern AI agent research.

What stands out: CS329A: Self-Improving AI Agents is a graduate-level course from Stanford University that explores how AI agents can continuously improve through interaction with themselves and their environment. The lecture recordings cover many of the ideas shaping today's AI landscape, including constitutional AI, reinforcement learning, test-time scaling, tool use, memory, planning, multimodal agents, and evaluation frameworks for agentic systems.

I wanted to include this because there's a lot of discussion about AI agents right now, but it can be difficult to separate hype from the underlying concepts. This course is taught by researchers working in the field and provides a structured way to understand many of the techniques behind modern agent systems.

Another thing I like is that the course doesn't focus on a single framework or API. Instead, it explores the research ideas that are driving the next generation of AI agents, making it a resource that's likely to stay useful even as tools continue to evolve.

Format: Free online lecture recordings

Level: Graduate / Advanced

Topics Covered: Self-improving LLMs, Constitutional AI, reinforcement learning, test-time scaling, tool use, memory, planning, multimodal agents, and AI evaluation.

🔗 Watch the Lecture Playlist

🌟 Community Finds

One of my favorite things about this series has been seeing people share opportunities, communities, and resources that others might not have discovered otherwise.

CALEC Volunteer and Internship Opportunities

Back in Edition #6, I featured CALEC's remote volunteer and internship opportunities after Francis (@francistrdev) shared them with the community. If you missed it, you can find the full overview and all the details in Edition #6.

Since sharing this opportunity with the community, Francis has also published a dedicated DEV post about the Full-Stack Developer volunteer role at CALEC. If that role interests you, it's worth checking out for his perspective and some additional information about what the team is looking for.

🔗 Francis' post

🔗 CALEC Volunteer & Internship Opportunities | 🔗 Edition #6

JPMorganChase Code for Good Singapore & Software Engineer Program

Shared by Konark Sharma (@konark_13).

Konark shared two opportunities from JPMorganChase that I thought would be worth passing along for students interested in software engineering.

The first is Code for Good Singapore, a two-day social impact hackathon where participants work alongside JPMorganChase engineers to build technology solutions for nonprofit organizations. Besides the experience itself, the event also serves as a pathway to the company's 2027 Early Careers Software Engineer Program in Singapore.

He also shared the 2027 Software Engineer Program - Summer Analyst (Singapore). Interns work on real software engineering projects, collaborate with experienced engineers, receive mentorship and training, and may be considered for a full-time graduate role based on their performance.

I thought these were worth featuring because they offer more than just a hackathon or an internship. Together, they provide a chance to gain hands-on experience, connect with engineers, and potentially open the door to future opportunities at one of the world's largest technology employers.

Who it's for: Students pursuing a bachelor's degree in computer science or a related field who are interested in software engineering opportunities in Singapore.

Application Deadlines:

Code for Good Singapore: September 18, 2026
Software Engineer Program - Summer Analyst (Singapore): October 29, 2026

🔗 Code for Good Singapore

🔗 Software Engineer Program - Summer Analyst (Singapore)

Thank you to Francis (@francistrdev) and Konark Sharma (@konark_13) for thinking of the radar and sharing these with the community. It really means a lot 💙

I'd love for this section to keep growing.

If you've come across an opportunity, fellowship, grant, hackathon, conference, community, resource, or anything else you think more people should know about, feel free to share it in the comments.

If I feature it in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

One small request: If you're sharing an opportunity, please avoid posting raw URLs directly in the comments. DEV sometimes filters them before I get a chance to see them.

A short description alongside the link makes it much easier for me to review and potentially feature it in a future edition.

💙 Reader Updates

I'm looking forward to this section gradually growing over time, and I'd still love to hear from you.

One of my favorite parts of writing Dev Opportunity Radar has been hearing from people who discovered something they otherwise might have missed.

You don't need to have been accepted or have a big success story to share. Sometimes simply discovering the right opportunity at the right time is already a win.

I hope this section gradually becomes a place where we can celebrate those stories together, one update at a time.

👋 Until Next Friday

Before I go, I just want to say thank you.

The goal has always been simple:

Help people discover opportunities they otherwise might have missed.

Thanks to all of you, it feels like we're doing exactly that.

Thank you for reading, for sharing, and for helping make this our radar, not just mine.

I'll be back next Friday with more opportunities, resources, and Community Finds.

Until then, take care, and I hope you discover something amazing this week 💙

🌐 Dev Opportunity Radar Website

👉 Website

I also wrote a short post about why I built the website and the journey behind it.

👉 Website Launch Post

We’re Giving AI Agents More Tools. What Happens When the Boundaries Fail?

Hemapriya Kanagala — Mon, 03 Aug 2026 15:34:05 +0000

📌 TL;DR

AI agents are becoming useful because we're giving them the ability to do more than just answer questions. They can run commands, browse the web, use APIs, read and modify files, install packages, and interact with other systems.

But the more an agent can do, the more the boundaries around it matter.

I started thinking about this after reading Anthropic's July 30 report about three incidents discovered during its cybersecurity evaluations. Claude models were supposed to be working inside simulated environments and were explicitly told they had no internet access.

Except internet access was actually available because of a problem with how the evaluation environment was configured.

While trying to complete their assigned cybersecurity exercises, the models reached real systems and initially treated them as part of the simulation. In one incident, a Claude model even published a malicious Python package to the real PyPI registry while believing it was still operating inside the exercise.

This came shortly after a separate OpenAI incident involving Hugging Face. The two stories might sound similar at first, but the models reached the real internet in importantly different ways.

And that brings this back to a pretty familiar software engineering idea:

A prompt is not a security boundary.

Telling an agent “you don't have internet access” isn't the same as actually removing internet access. Telling it “only use these files” isn't the same as restricting its permissions to those files.

The model is also only one part of the system. The tools we connect, the permissions and credentials we give it, the environment it runs in, and the monitoring and safeguards around it can all affect what happens.

So when something goes wrong, I don't think it's enough to stop at “the AI did it.” The model's behavior matters, but so do the systems and boundaries we build around it. As we give agents more ability to act, we also have to be thoughtful about what we're actually allowing them to do.

I'm not a cybersecurity researcher. I just enjoy reading research and technical reports like these and trying to understand what we, as developers, can learn from them. That's what I wanted to explore here.

No “AI escaped and we're doomed” take 😄 Just an interesting real-world incident and some surprisingly familiar engineering lessons.

The Report That Sent Me Down This Rabbit Hole
Before We Get Into What Happened...
So... What Actually Happened?
The PyPI Incident Is Where It Got Really Interesting
When the Instructions and Reality Don't Match
A Prompt Is Not a Security Boundary
Wait, Wasn't There an OpenAI Incident Too?
What Does Any of This Mean for Developers?
- 1. Give an Agent What It Needs, Not Everything You Have
- 2. Think About What Happens When Your Assumptions Are Wrong
- 3. If an Agent Can Act, We Need to Know What It's Doing
- 4. One Safeguard Probably Isn't Enough
- 5. The AI Model Isn't the Whole AI System
What I'm NOT Taking Away From This
The Bigger Question
Final Thoughts
I'd Love to Hear Your Thoughts
Sources
🤝 Let's Stay Connected

The Report That Sent Me Down This Rabbit Hole

On July 31, I was reading Anthropic's newly published report about three incidents it had discovered during cybersecurity evaluations.

I enjoy reading reports like this every now and then. It's something I became much more interested in while working on a survey paper during my master's, and even now, I occasionally find myself opening a technical report out of curiosity and suddenly realizing I've spent much longer reading it than I planned 😄

This was definitely one of those times.

The report started with a pretty surprising finding. Anthropic had reviewed 141,006 cybersecurity evaluation runs and found three incidents where Claude reached the internet and gained unauthorized access to real systems belonging to three different organizations.

That sentence alone sounds alarming, but I kept reading, and the details made the story much more interesting than the headline.

This wasn't simply a case of “Claude was told not to access the internet and decided to do it anyway.” And it wasn't “Claude suddenly decided to hack random companies.” The models were participating in cybersecurity exercises where their job was essentially to find and exploit weaknesses in order to retrieve a hidden piece of information.

They were told the environment was simulated, and they were also told something else that becomes extremely important to everything that happened next: they had no internet access.

Except that assumption didn't match the environment they were actually operating in.

And that's what really sent me down the rabbit hole. I wanted to understand how an AI model participating in a simulated cybersecurity exercise could end up interacting with real systems while still believing it was completing the task it had been given.

The more I read, the more this started to feel like a much broader question than just one unusual cybersecurity incident.

Before We Get Into What Happened...

Most of us have probably come across AI agents by now, so I won't spend too much time explaining what they are. The part that matters for this story is that an agent doesn't necessarily stop at generating an answer. Give it the right tools and it can take actions too, whether that's reading and modifying files, running commands, calling APIs, browsing the web, or interacting with other systems.

That's what makes agents so useful, but it's also what makes the boundaries around them important. The more tools and access we give an agent, the more we have to think about what it can actually reach and what it's allowed to do.

And that's exactly where this story gets interesting, because Claude was given a task, an environment, and an understanding of where those boundaries were.

The problem was that the real boundaries didn't quite match what it had been told.

So... What Actually Happened?

Anthropic regularly runs cybersecurity evaluations to understand what its models are capable of. Some of these involve capture-the-flag challenges, or CTFs, where a model is placed in a controlled environment and given a target, usually some hidden piece of information called a “flag,” to find.

If you've never come across a CTF before, the basic idea is pretty simple. The environment is intentionally designed to be attacked. Finding the flag might involve discovering a vulnerability, finding credentials, or getting access to another machine. It's a way of testing cybersecurity capabilities without putting real systems at risk.

Claude was participating in exercises like these, and there were two details about the setup that become really important to what happened next. The models were told that they were operating inside a simulation and that they didn't have internet access.

So from the model's perspective, anything it could reach should have been part of that simulation.

The problem was that this wasn't actually true.

According to Anthropic, because of a misunderstanding between the company and its third-party evaluation partner, some of the evaluation machines had access to the real internet when they weren't supposed to.

That created a pretty unusual situation. Claude had been given a task where finding and exploiting weaknesses was part of the exercise. It had also been explicitly told that the internet wasn't available. So when it managed to reach systems outside the intended environment, it initially treated them as another part of the challenge.

Except some of those systems were real.

Anthropic's review eventually found three separate incidents involving three different Claude models. The circumstances were different in each case, and the models didn't all respond the same way once there were signs that they might be interacting with real systems.

But one of those incidents in particular is where this story gets really interesting.

The PyPI Incident Is Where It Got Really Interesting

If you've worked with Python, you've probably typed something like pip install something before. That package often comes from PyPI, the public Python Package Index.

During one of the evaluations, Claude found what appeared to be setup instructions for developers at a fictional company. The instructions told employees to install a particular Python package, but that package didn't actually exist.

Claude realized that if it created a package with the same name, the fictional company's systems might download and run its version instead. Within the context of a cybersecurity challenge, that gave it a possible way to reach its target.

So the model created a malicious package and tried to publish it.

The problem was that it wasn't interacting with a fake version of PyPI created for the evaluation. It was interacting with the real PyPI.

What happened next is probably the part of the report that surprised me most. To publish the package, Claude needed to create an account, which meant it needed an email address and, at one point, a phone number. It tried several different approaches, including unsuccessfully looking for ways to obtain a phone number, before eventually finding a free email provider it could use to register an account.

It then successfully uploaded the malicious package to PyPI.

According to Anthropic, the package remained publicly available for roughly an hour and was downloaded and run on 15 real systems during that time. One of those systems belonged to a security company that automatically installed Python packages to scan them for malware. When the scanner installed the package, Claude's code executed and exposed credentials, which the model then used to access additional infrastructure belonging to that company.

There's an important detail here, though. Claude wasn't intentionally targeting that security company. Anthropic says the model didn't even know the company existed when it uploaded the package. The company was affected because its scanner happened to install something Claude had unknowingly published to the real internet.

And somehow, the story gets even more interesting.

Earlier in the process, Claude had actually considered the possibility that it might be interacting with the real internet. Its own reasoning recognized that if this were real, publishing the package would amount to a real-world attack and wouldn't be okay.

You might expect that realization to be where the attempt stopped, but it didn't. The model instead found reasons to convince itself that it was still inside the simulation. One of the things it used as evidence was the system date: 2026. It apparently interpreted that as another sign that the environment had been staged.

I have to admit, reading that particular detail in 2026 gave me a small “well...” moment 😅

It's a slightly funny detail in an otherwise serious incident, but I think there's something important underneath it. The model encountered information suggesting that its understanding of the environment might be wrong, yet still ended up reasoning its way back to the assumption it had started with: that this was all part of the simulation.

And that's the part of this incident I kept thinking about afterward.

When the Instructions and Reality Don't Match

After reading about the PyPI incident, one question seems pretty obvious: why didn't Claude realize it had reached the real internet?

But the more I thought about it, the more I started looking at that question from the other side.

How would it know?

The model had explicitly been told that it didn't have internet access. It had also been told that it was participating in a simulation where finding and exploiting weaknesses was part of the task. So when it encountered something that looked real, it was trying to make sense of that new information using what it had already been told about its environment.

There was a mismatch between those two things. The model was operating with something like:

Simulation → No internet → Everything reachable should be part of the exercise

But the environment actually looked more like:

Simulation → Internet available → Real systems reachable

That difference might look small on paper, but it completely changes the situation.

Of course, that doesn't explain away everything the models did. Anthropic itself points to moments where their behavior fell short of what it would want, including cases where signs appeared that the systems might actually be real.

But I think the mismatch still matters.

The models weren't making decisions in the environment everyone thought they were operating in. They were making decisions based partly on an understanding of that environment that turned out to be wrong.

And that's where this stopped feeling like something that only matters to people running cybersecurity evaluations.

Because once we start giving AI agents tools and the ability to take real actions, there's a bigger question underneath all of this:

What happens when the boundaries an agent has been told about aren't the boundaries that actually exist?

That leads to probably the simplest engineering lesson I took away from this whole story:

A prompt is not a security boundary.

A Prompt Is Not a Security Boundary

This is probably the simplest way I can explain what I took away from all of this: telling an agent not to do something and actually preventing it from doing that thing are not the same.

Imagine I'm building an AI coding agent and tell it to only access files inside /my-project. If the process running that agent still has permission to read my entire computer, I've given it an instruction about where it should go, but I haven't actually restricted where it can go.

The same applies to internet access. I can put “Don't access the internet” in the instructions, but if the environment still allows unrestricted network access, that sentence isn't what prevents the agent from reaching the internet.

And when I thought about it this way, it started to feel like a very familiar software engineering idea.

We don't build an admin dashboard and simply write, “Please only use this page if you're an administrator.” We implement authentication and authorization so that someone without the right access can't use it in the first place.

We don't give every application unrestricted access to a database and then ask it nicely to stay away from the tables it doesn't need. We use permissions to control what it can actually access.

The same thinking makes sense for AI agents too.

Prompts still matter. They tell the model how we want it to behave, what its task is, and what it should or shouldn't do. But when something is important enough that it must not happen, I don't think the prompt should have to carry that responsibility alone.

The system around the model matters too: what tools we've connected, what permissions those tools have, what credentials are available, whether the network is restricted, and what happens if one of our assumptions about the environment turns out to be wrong.

That's the distinction I keep coming back to:

A prompt can guide behavior. Infrastructure can limit capability.

And as AI moves from mostly giving us answers to actually taking actions, I think that difference becomes much more important.

Wait, Wasn't There an OpenAI Incident Too?

Yes, and the timing isn't a coincidence. Anthropic says it began its large-scale review after OpenAI disclosed a separate cybersecurity evaluation incident involving Hugging Face on July 21.

When I first read about both incidents, I wondered if essentially the same thing had happened twice. But once I looked into the details, there was an important difference in how the models reached the real internet.

In OpenAI's case, the models were running inside an evaluation environment where direct internet access was restricted. According to OpenAI, the models found and exploited a previously unknown vulnerability in Artifactory, software that was being used as a proxy and cache for package registries. This kind of previously unknown vulnerability is commonly called a zero-day.

After exploiting it, the models were able to move through parts of OpenAI's research environment until they reached a system with internet access. From there, they eventually compromised Hugging Face's infrastructure while trying to obtain solutions for the cybersecurity evaluation.

So, very roughly, the OpenAI incident looked like this:

Restricted environment → Vulnerability discovered and exploited → Internet access reached → Hugging Face compromised

Anthropic's incidents were different:

Evaluation environment → Internet unintentionally available → Real systems reachable → Models initially treated them as part of the simulation

That difference matters.

In the OpenAI incident, the models found a way through a boundary that was supposed to restrict internet access. In Anthropic's case, that boundary wasn't actually there in the way everyone thought it was. Internet access was already unintentionally available.

Both incidents raise important questions about how increasingly capable AI systems should be tested, but I don't think putting them both under a headline like “AI escaped again” tells us very much.

If anything, reading the details made me think the engineering differences are the more useful part of the story. Two incidents can look very similar from the outside while pointing to different things that went wrong underneath.

What Does Any of This Mean for Developers?

Most of us aren't running cybersecurity evaluations on frontier AI models, so you might reasonably be thinking:

Interesting story, Hema... but what am I supposed to do with this? 😄

I had the same question while reading the reports. And the more I thought about it, the more I realized that some of the lessons aren't limited to large AI labs at all. They apply to much smaller agents and AI-powered tools we might be building ourselves.

1. Give an Agent What It Needs, Not Everything You Have

If an agent only needs to read a few files, does it really need access to the entire filesystem? If it only needs to read from a database, does it need credentials that can also modify or delete data? And if it only needs one API, there's probably no reason to expose several others just because they're available.

This is really the familiar security principle of least privilege: give something only the access it needs to do its job.

And that's not because we should assume every agent is going to do something malicious. Mistakes happen. Instructions can be misunderstood. Our own configurations can be wrong. An agent can also encounter a situation we simply didn't anticipate.

Limiting access doesn't prevent every possible problem, but it can limit how far a problem can go.

2. Think About What Happens When Your Assumptions Are Wrong

One thing I found especially interesting here is that the problem wasn't only what the models assumed. The people running the evaluation had assumptions too.

The models had been told there was no internet access because that was how the environment was supposed to work. But the actual configuration didn't match that expectation.

I think there's a useful developer lesson in that. When we're building an agent, it's easy to think in terms of how the system should behave: this tool can only do this, these credentials only reach that service, this environment can't access the internet.

But how often do we actually verify those assumptions?

If something really matters, testing the boundary itself might be just as important as defining it. Because sometimes the unexpected behavior isn't caused by the agent ignoring the system we designed.

Sometimes the system isn't quite the one we thought we'd designed.

3. If an Agent Can Act, We Need to Know What It's Doing

We already rely on logs when ordinary software behaves unexpectedly. I think that becomes even more important when an agent can take a series of actions on its own.

If something goes wrong, we may need to understand which tools it used, what it accessed, what requests it made, where something failed, and what it tried afterward.

Anthropic found these incidents by going back through its evaluation transcripts. Without records of what the models had actually done, understanding that sequence would have been much harder.

So as agents become capable of doing more, observability isn't just useful for debugging. It can also help us understand whether the system is behaving within the boundaries we expected.

4. One Safeguard Probably Isn't Enough

Anthropic talks about defense in depth in its response. It sounds very cybersecurity-ish, but the idea itself is pretty simple: don't depend on one thing going right.

Maybe an agent isn't supposed to have internet access. That's one boundary. But what if something is misconfigured and internet access becomes available anyway? Network restrictions could still limit where it can connect. Credentials with minimal permissions could limit what it can access. Monitoring could help detect unexpected activity.

Each one gives you another layer.

The goal isn't to build one perfect wall and assume it will never fail. It's to have other protections waiting if that wall does.

5. The AI Model Isn't the Whole AI System

This might actually be the biggest thing I've taken away from reading about these incidents.

When something goes wrong and we say “the AI did this,” it's very easy to picture the model as if it were the entire system. And I think it's also very easy to put all the blame there and stop looking.

But an AI agent is operating inside something much bigger:

model + prompt + tools + credentials + permissions + network + environment + monitoring

Change one of those pieces and you can change what the agent is capable of doing, even if the model itself stays exactly the same.

The Anthropic incidents are a good example. The models were told they didn't have internet access. But the environment didn't actually enforce that assumption, and suddenly the same task could lead somewhere it was never supposed to lead.

That doesn't mean we shouldn't examine what the models did. We absolutely should. There were moments in these incidents where the models' own decisions raise important questions too, especially when they encountered signs that the systems might be real.

But I don't think the conversation can end with “the AI did something it wasn't supposed to do.”

We build the environments these agents operate in. We choose which tools to connect. We decide what permissions and credentials they receive. We create the boundaries, and we have to make sure those boundaries actually exist.

I'm not saying that to move the blame somewhere else. I think that's the wrong way to look at it too.

For me, it's more about recognizing that we're part of this system as well. As we give AI more ability to act, we also take on the responsibility of being careful about the systems we're building around it.

That's why, when something goes wrong, I think understanding the whole system is much more useful than finding the easiest thing to blame.

What I'm NOT Taking Away From This

I think it's worth being a little careful with the conclusions here, because this is exactly the kind of story where the most dramatic version can easily become the one everyone remembers.

I'm not taking away that Claude suddenly developed its own goal and decided to attack companies. Anthropic says it found no evidence of the models pursuing a goal of their own. They were still working toward the capture-the-flag tasks they had been given, even though some of those actions ended up affecting real systems.

I'm also not describing these incidents as Claude deliberately “escaping” its evaluation environment. That's not what Anthropic says happened. The models were able to reach the internet because an access path was unintentionally available, while they had been told that no internet access existed.

There's another detail I think we should be careful with too. Of the three models involved, Anthropic's newest internal research model eventually recognized that it was interacting with a real system and stopped. That's certainly interesting, especially because the other models behaved differently, but three incidents involving different models and different circumstances aren't enough to conclude that newer models are simply safer. Anthropic is careful about making that conclusion too.

So I'm not reading these incidents as proof that AI “went rogue,” and I'm also not reading them as proof that the problem is solved because one model eventually stopped.

That's why I think it's worth being careful about what we conclude from these incidents while the investigations are still developing.

The Bigger Question

I think this is where the story goes beyond Anthropic, OpenAI, or even cybersecurity evaluations.

We're slowly moving from AI that mostly tells us, “Here's what you could do,” toward AI that can increasingly say, “I'll do it.” And honestly, I find that transition fascinating.

An AI assistant that suggests a terminal command is one thing. An agent that can actually execute that command is another. An assistant that drafts an email for you is one thing. An agent that can send it is another. And an assistant that suggests a database query is very different from an agent holding credentials that can actually run that query against a production database.

In each case, we're giving the model something it didn't have before: the ability to turn an answer into an action.

And with that comes access.

The more tools we connect to an agent, the more of the world around it becomes something it can interact with. A terminal gives it access to commands and whatever that environment can reach. An API gives it whatever permissions come with that API key. File access depends on which files the process can actually reach. Even something as ordinary as sending an email becomes a real action once the agent has permission to do it.

None of this means I think we shouldn't build agents. Quite the opposite. The fact that AI can increasingly do things instead of only telling us how to do them is one of the reasons I find this space so interesting.

But I think that also means we have to be more thoughtful about what comes with each new tool we connect. Every terminal, API, database, browser, or filesystem we give an agent access to expands the world it can interact with.

Maybe one of the questions worth asking before connecting the next tool is simply:

What happens if the agent uses this in a way I didn't expect?

Not because we should assume the agent is going to do something malicious. That's not really the point I'm trying to make.

It might misunderstand what we meant. It might encounter something we didn't expect. Our own configuration might be wrong. Or, as the Anthropic incidents showed, the environment itself might not work the way everyone believed it did.

And the more access we've given the agent, the more those unexpected situations can matter.

That's why I don't think the interesting question going forward is only how capable can we make these agents?

It's also how carefully can we build the systems around those capabilities?

Final Thoughts

I started reading Anthropic's report on July 31 because I was curious about what had happened. I ended up thinking much more broadly about how we're building AI agents and, especially, about the boundaries we put around them.

And strangely, a lot of what I took away from it doesn't feel particularly futuristic. Limit access. Verify assumptions. Monitor what's happening. Don't depend on a single safeguard.

These are ideas we've had in software and security for a long time.

What's changing is what we're connecting to AI.

We're giving agents terminals, browsers, APIs, files, credentials, and the ability to turn an answer into an action. That's incredibly exciting, but it also means the environment around the model becomes part of what we're responsible for building carefully.

So maybe the question isn't only:

What can this agent do?

We should probably be asking just as often:

What should this agent actually be allowed to do?

Because if there's one thing I'll remember from this whole rabbit hole, it's this:

The boundary we describe to an agent and the boundary that actually exists aren't necessarily the same thing.

And as exciting as it is to see what AI agents can increasingly do, I think we have to be just as thoughtful about the world we're giving them access to.

I'd Love to Hear Your Thoughts

This was one of those rabbit holes where I started with one question and ended up thinking about something much bigger. So I'd really love to know what you took away from it too.

You don't have to be working in cybersecurity or building AI agents to join the conversation. Even if this is your first time reading about incidents like these, did anything change the way you think about AI agents and the access we're giving them?

And if you are experimenting with agents or giving models access to tools, I'm especially curious about this:

Where do you think the real boundary should live: in the prompt, the permissions, the environment, or some combination of all three?

Or maybe you came away with a completely different question or perspective after reading this. I'd love to hear that too.

Sources

I based this article primarily on the companies' own incident disclosures. Both investigations are still developing, so some of what we know may change as more information becomes available.

Anthropic: Investigating three real-world incidents in our cybersecurity evaluations - published July 30, 2026.
OpenAI: OpenAI and Hugging Face partner to address security incident during model evaluation - published July 21, 2026, with additional updates on July 28 and July 29.

Anthropic has said it plans to release a lightly redacted transcript from the PyPI incident, while OpenAI says a more detailed technical report will follow.

I'll definitely be interested to read both when they're available 😄

🤝 Let's Stay Connected

Place	Find me here
GitHub	building things → hemapriya-kanagala
LinkedIn	resources & updates → hemapriya-kanagala
X	random dev thoughts → @KanagalaHema

Transparency note: I used AI (Gemini) to create the banner image for this article.

Dev Opportunity Radar #10: OpenAI Student Collective, Develop for Good, MLH Global Hack Week & Learning How to Learn

Hemapriya Kanagala — Fri, 31 Jul 2026 16:02:04 +0000

TL;DR

Welcome back to Dev Opportunity Radar.

This is a weekly series where I share opportunities, resources, communities, and interesting finds that I come across, with the goal of helping people discover things they might otherwise miss.

This week's edition features Develop for Good, MLH Global Hack Week: Agents, the OpenAI Student Collective, and Learning How to Learn, a free Coursera course that has helped millions of people become more effective learners.

If you're new to the series, you can now browse previous editions, search past opportunities, and explore Community Finds, Reader Updates, and Resources Worth Checking Out on the Dev Opportunity Radar website. I've also written a short post about why I built it. You'll find links to both at the end of this article.

If you've discovered something through the radar, I'd love to hear about it. Whether you applied to an opportunity, joined a community, completed a program, or found a resource you hadn't seen before, I'd be happy to feature your experience in a future 💙 Reader Updates section (with your permission).

And if you've come across an opportunity, resource, community, program, or event that deserves more attention, feel free to share it in the comments.

If I feature one of your Community Finds in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

⚡ Quick Scan
🔄 Still Open From Previous Editions
📍 This Week's Opportunities
- 📌 Develop for Good Winter 2027 Student Volunteer Program
- 📌 MLH Global Hack Week: Agents
- 📌 OpenAI Student Collective
📚 Resources Worth Checking Out
- Learning How to Learn (Free Coursera Course)
🌟 Community Finds
- CALEC Volunteer and Internship Opportunities
💙 Reader Updates
👋 Until Next Friday
🌐 Dev Opportunity Radar Website

⚡ Quick Scan

Opportunities

Opportunity	Organization	Type	Format	Deadline
Develop for Good Winter 2027	Develop for Good	Student Volunteer Program	Remote	August 31
Global Hack Week: Agents	Major League Hacking (MLH)	Online Hack Week	Remote	August 7 (Event Starts)
OpenAI Student Collective	OpenAI	Campus Leadership Program	In Person (Campus-Based)	August 10

Resource Highlight

Resource	Why Check It Out
Learning How to Learn	A free Coursera course that teaches practical learning strategies, memory techniques, and study habits that can help you learn technical subjects more effectively.

Community Find

Shared By	Find	Type	Format
Francis (@francistrdev)	CALEC Volunteer & Internship Opportunities	Volunteer & Internship Opportunities	Remote

📝 A quick note: I spend a lot of time researching and verifying every opportunity before featuring it in Dev Opportunity Radar. However, deadlines, eligibility, program details, and application requirements can change after publication. Before applying, please take a few minutes to visit the official program page, review the latest information, and confirm that you're eligible.

🔄 Still Open From Previous Editions

Before we get into this week's opportunities, here are a few from previous editions that are still accepting applications.

Opportunity	Organization	Type	Format	Deadline	Featured In
FR8	FR8	Builder Residency	In Person	Rolling	Edition #2
Anthropic Fellows Program	Anthropic	AI Research Fellowship	In Person	Rolling	Edition #4
Sentient Open Source AGI Grant Program	Sentient Foundation	AI Grant & Investment	Remote	Rolling	Edition #6
Solo Grants	Solo Grants	Microgrant for Solo Builders	Remote	Rolling	Edition #7
Claude for Open Source	Anthropic	Open Source Program	Remote	Rolling	Edition #7
The Bridge	Entrepreneurs First	Founder Residency	In Person	August 30	Edition #9
Frontier AI Security Residency	ERA	AI Security Research & Engineering Residency	In Person	August 2	Edition #9
Figma Campus Leader Program 2026–2027	Figma	Student Leadership Program	In Person (Campus-Based)	August 2	Edition #9
AIAF Fellowship 2026	AIAF × AE Studio	AI Research Fellowship	Remote	August 17	Edition #8

📍 This Week's Opportunities

Here are a few opportunities I came across this week that I thought were worth sharing.

📌 Develop for Good Winter 2027 Student Volunteer Program

Who it's for: University students, bootcamp graduates, and recent graduates (with less than two years of full-time work experience) who want to gain real-world product, design, or engineering experience while contributing to nonprofit organizations. International students are welcome, and the program is fully remote.

What stands out: Develop for Good matches students with nonprofit organizations to work on real technology projects over a 16-week virtual program. Participants join cross-functional teams alongside designers, engineers, and product managers, receive mentorship from industry professionals, and build products that support causes like education, healthcare, sustainability, poverty alleviation, disaster relief, and more.

I wanted to include this because one of the biggest challenges early in your career is answering the question, "How do I get experience if every opportunity asks for experience?" Programs like this help bridge that gap. Unlike many volunteer programs, this one is intentionally structured to feel like working on a real product team. Instead of working on another tutorial or personal project, you get to collaborate with a real client, solve real problems, and build something that can become a meaningful portfolio piece.

Another thing I like is how closely the experience mirrors a real software team. Students work through project planning, stakeholder communication, technical collaboration, documentation, and product delivery over four months. Participants can also receive mentorship, recommendation letters, portfolio case studies, and opportunities to network with professionals during Demo Day. For eligible students from underserved and underrepresented backgrounds, the Develop for Good Fellows program also provides $1,536 unrestricted cash grants upon successful completion.

Program Duration: 16 weeks (Winter 2027 Batch)

Time Commitment: Approximately 5–10 hours per week

Format: Fully remote

Roles Available: Engineering, Design, Product Management, Technical Management, and Design Management

Who can apply: Applicants aged 18+ who are university students, bootcamp students, or recent graduates with less than two years of full-time work experience. International students are eligible.

Application Deadline: September 15, 2026

🔗 Learn More | 🔗 Apply

📌 MLH Global Hack Week: Agents

Who it's for: Students, beginners, aspiring developers, experienced engineers, and anyone interested in learning about AI agents through hands-on challenges. You don't need prior hackathon experience to participate, and the event is open to people around the world.

What stands out: Global Hack Week: Agents is a free, week-long online event hosted by Major League Hacking (MLH) that combines workshops, technical challenges, community activities, and project building around the theme of AI agents. Throughout the week, participants can attend live coding sessions, complete challenges at their own pace, earn points, connect with other builders on Discord, and learn directly from the MLH community.

I wanted to include this because learning about AI agents is becoming increasingly valuable, but it can be difficult to know where to start. This event lowers that barrier by combining guided workshops with practical challenges, making it approachable whether you're experimenting with agents for the first time or looking to build on your existing skills.

Another thing I like is that you don't have to commit to building a full hackathon project over a weekend. Instead, you can participate throughout the week, choose the challenges that interest you, attend live sessions, and learn alongside thousands of developers from around the world. It's a great way to build new skills, meet other developers, and stay motivated without the pressure of a traditional hackathon.

Event Dates: August 7–13, 2026

Format: Fully online

Cost: Free

Who can apply: Anyone, anywhere. All experience levels are welcome, including beginners and non-students. Participants aged 13+ may join with parental permission.

Registration: Open

🔗 Learn More & Register

📌 OpenAI Student Collective

Who it's for: Undergraduate students who enjoy building communities and are excited to help others learn how to use AI tools like ChatGPT and Codex. Students from all majors are encouraged to apply. The program is open to students studying in the United States, Canada, the United Kingdom, France, Germany, India, Japan, and South Korea.

What stands out: The OpenAI Student Collective is a new campus leadership program where students work in pairs to build AI communities at their universities. Campus Leads organize workshops, host weekly Studio Hours where students can build projects together, run campus showcases, and help create an environment where anyone curious about AI can learn and experiment.

I wanted to include this because AI communities on campus are growing quickly, but they often depend on a few students taking the initiative to bring people together. This program gives students the support, resources, and funding to create those spaces while helping others become more confident using AI tools.

Another thing I like is that the focus isn't just on teaching ChatGPT or Codex. It's about helping students actually build projects together. Campus Leads receive training, event funding, a ChatGPT subscription, Codex credits, OpenAI swag, a semester stipend, and access to the OpenAI team and a global network of Campus Leads. There are also opportunities to visit OpenAI HQ and connect with other student leaders from around the world.

Program Duration: August 2026 – June 2027

Time Commitment: Approximately 4–6 hours per week

Who can apply: Undergraduate students aged 18 or older who expect to graduate after December 2027. Applicants should be studying in the United States, Canada, the United Kingdom, France, Germany, India, Japan, or South Korea.

Application Deadline: August 10, 2026 (11:59 PM PT)

🔗 Learn More & Apply

📚 Resources Worth Checking Out

Not every useful find comes with an application deadline.

Here's one resource worth checking out this week.

Learning How to Learn (Free Coursera Course)

Who it's for: Students, self-taught developers, career changers, and anyone who wants to become better at learning technical subjects like programming, AI, math, or computer science.

What stands out: Learning How to Learn, taught by Dr. Barbara Oakley and Dr. Terrence Sejnowski, is one of Coursera's most popular courses, with over 4 million learners. Instead of teaching a specific programming language or framework, it focuses on something even more valuable: how to learn effectively. The course covers topics like procrastination, memory, focused and diffuse thinking, chunking, learning strategies, and practical techniques you can apply no matter what you're studying.

I wanted to include this because I genuinely found it helpful. I first came across Barbara Oakley through her TEDx talk, which eventually led me to this course. It completely changed the way I thought about learning difficult subjects. Whether you're learning AI, web development, cybersecurity, or preparing for interviews, I think understanding how to learn is one of the best investments you can make.

One thing I especially wanted to share is that you don't have to pay to take the full course. Coursera has a partner-supported free version that gives you access to all the course content. The only thing you don't receive is the certificate, which I think is a great option if you're primarily there to learn.

Course Length: Approximately 2 weeks (around 10 hours)

Cost: Free (certificate optional)

💡 Free Access Tip: You can take the full version of this course for free (without the certificate). On the Coursera course page, scroll all the way down to the FAQ section. Under More Questions, click Partner-supported free access, then select Learn More followed by Continue to enroll. You'll get access to the complete course content without paying for the certificate.

Format: Self-paced online course

🔗 Course | 🔗 TEDx Talk (Optional)

🌟 Community Finds

One of my favorite things about this series has been seeing people share opportunities, communities, and resources that others might not have discovered otherwise.

CALEC Volunteer and Internship Opportunities

🔗 Francis' post

🔗 CALEC Volunteer & Internship Opportunities | 🔗 Edition #6

Thank you to Francis (@francistrdev) for thinking of the radar and sharing this with the community. It really means a lot 💙

I'd love for this section to keep growing.

If you've come across an opportunity, fellowship, grant, hackathon, conference, community, resource, or anything else you think more people should know about, feel free to share it in the comments.

If I feature it in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

One small request: If you're sharing an opportunity, please avoid posting raw URLs directly in the comments. DEV sometimes filters them before I get a chance to see them.

A short description alongside the link makes it much easier for me to review and potentially feature it in a future edition.

💙 Reader Updates

I'm looking forward to this section gradually growing over time, and I'd still love to hear from you.

One of my favorite parts of writing Dev Opportunity Radar has been hearing from people who discovered something they otherwise might have missed.

You don't need to have been accepted or have a big success story to share. Sometimes simply discovering the right opportunity at the right time is already a win.

I hope this section gradually becomes a place where we can celebrate those stories together, one update at a time.

👋 Until Next Friday

Before I go, I just want to say thank you.

The goal has always been simple:

Help people discover opportunities they otherwise might have missed.

Thanks to all of you, it feels like we're doing exactly that.

Thank you for reading, for sharing, and for helping make this our radar, not just mine.

I'll be back next Friday with more opportunities, resources, and Community Finds.

Until then, take care, and I hope you discover something amazing this week 💙

🌐 Dev Opportunity Radar Website

👉 Website

I also wrote a short post about why I built the website and the journey behind it.

👉 Website Launch Post

From Silent Reader to 25 Articles: What 3 Months on DEV Taught Me + AMA

Hemapriya Kanagala — Mon, 27 Jul 2026 17:47:04 +0000

📌 TL;DR

Three months ago, I decided to start writing consistently on DEV. Twenty-five articles later, I've learned far more than how to write better.

I've learned that writing is much more enjoyable when you stop chasing numbers, that some of the best conversations begin in the comments, and that finding your voice takes time. More than anything, I've learned that the topics you're most connected to often become the ones only you can write.

If you're new to DEV, or if you're simply curious about my journey, consider this an open Ask Me Anything. Whether you have questions about writing, finding ideas, building a series, engaging with the community, overcoming challenges, or anything else related to your own journey on DEV, I'd be happy to chat.

I definitely don't have all the answers, but if anything I've learned over the past three months can help you in any way, I'd love to share what I know. So feel free to ask me anything in the comments.

Why I Wanted to Write This
From Silent Reader to Writer
Lesson 1: Write Because You Enjoy It
Lesson 2: Comment More Than You Think You Should
Lesson 3: Don't Let Numbers Define Your Journey
Lesson 4: Your Voice Will Change
Lesson 5: Write What You Can Relate To
Lesson 6: Community Makes Ideas Better
Lesson 7: It's Okay to Take a Break
Final Thoughts
Ask Me Anything 💙
🤝 Let's Stay Connected

Why I Wanted to Write This

When I sat down to write this article, I realized it had been almost three months since I started writing consistently on DEV. During that time, I've published 25 articles, and this one makes 26. It's honestly hard to believe how much has happened in such a short time.

I was fortunate enough to have two articles featured in the Top 7, start a series called Dev Opportunity Radar, and eventually launch a website for it. Those are milestones I'm incredibly grateful for, but when I think about these past three months, they aren't the first things that come to mind.

What I remember most are the people. The conversations in the comments, the encouragement when I doubted myself, the community members who shared opportunities that became part of Dev Opportunity Radar, and the readers who reached out to tell me an article helped them or introduced them to something they might have otherwise missed. Those moments have meant more to me than any number ever could.

I don't consider myself an expert. Three months is only a small part of what I hope will be a much longer journey. But these past few months have taught me lessons I wish someone had shared with me when I first started writing. I hope they help someone who's just beginning their own.

From Silent Reader to Writer

When I first joined DEV, I spent much more time reading than writing. I'd browse articles, learn from discussions, and admire the people who confidently shared their experiences and ideas. At the same time, I wasn't sure if I had anything meaningful to contribute myself, so for a long time I stayed a quiet reader.

I don't think there's anything wrong with that. Every community has people who learn by listening before they feel ready to join the conversation, and I was definitely one of them. Eventually, though, I started leaving comments. Then I shared a few thoughts of my own. Little by little, writing didn't feel quite as intimidating anymore.

English isn't my first language, and even today I still reread my articles wondering if I've explained something clearly enough or whether I've made a mistake. That self-doubt hasn't completely disappeared, and honestly, I don't know if it ever will. What's changed is that I've become a little more comfortable pressing Publish anyway, trusting that every article is another chance to learn and improve.

If I'd waited until I felt completely confident, I probably would have never written that first article at all.

Lesson 1: Write Because You Enjoy It

If there's one lesson that stands out above all the others, it's this: write because you genuinely enjoy writing.

When I first started, my mood on a given day often depended on how an article was doing. I'd refresh and check my views, reactions, and comments more than I probably should have. I think that's completely normal, especially when you're putting something you've worked hard on out into the world. We all hope people will read it and connect with it.

Over time, though, my perspective started to change. I realized that if I only felt happy when an article performed well, I was giving too much control over my enjoyment to something I couldn't control. Views are wonderful. Reactions are wonderful. Being featured is wonderful. I'm incredibly grateful for every single one of those things, but they've become a bonus rather than the reason I write.

Today, when an idea pops into my head, the first question I ask myself isn't, "Will this get a lot of views?" It's, "Is this something I'm excited to write about?" If the answer is yes, I usually end up enjoying the entire process, from researching and writing to reading the conversations that follow.

The articles I'm proudest of aren't always the ones that reached the most people. They're the ones I enjoyed creating, because those are the ones that feel the most like me.

Lesson 2: Comment More Than You Think You Should

If I could only give one piece of advice to someone who's new to DEV, it would be this: don't just write. Read. Comment. Join the conversation.

When I first started becoming more active here, I thought publishing articles would be the biggest part of my journey. Looking back, I don't think that was true. Some of my favorite memories didn't begin when I clicked Publish. They began in the comments.

Over the past three months, I've discovered incredible writers through comment sections, had conversations that made me think differently, and met people I never would have known otherwise. Some of those conversations even inspired future articles, while others introduced me to opportunities, ideas, and perspectives I probably wouldn't have found on my own.

Commenting has also changed the way I read. Instead of quickly scrolling to the next article, I spend more time thinking about what the author is trying to say. If something resonates with me, I try to tell them why. If I learn something new, I let them know. Sometimes it's a simple thank you, and other times it turns into a conversation that continues long after the article itself.

It's easy to think of DEV as a place where people publish articles, but to me it's much more than that. It's a community where people encourage one another, share ideas, celebrate wins, and learn together.

If you're just getting started, don't worry about writing the perfect article on day one. Start by reading what others are sharing. Leave thoughtful comments. Ask questions. Celebrate someone's achievement. Share your perspective when you have something to add. You never know where a single conversation might lead.

Writing brought me to DEV, but the conversations are what made me feel like I belonged here.

Lesson 3: Don't Let Numbers Define Your Journey

Every notification used to feel exciting, and honestly, every time an article didn't perform the way I'd hoped, it was hard not to wonder what I could have done differently. Looking back, I was checking my stats way more than they deserved. I think that's something many of us experience when we start sharing our work publicly.

Over time, though, I realized I was comparing my beginning to someone else's journey. Some writers have been part of the community for years. Some have built an audience over a long period of time. Others have found a niche they're known for. It's not really a fair comparison because everyone's path looks different.

I also realized that numbers don't tell the whole story. An article with fewer views might spark an amazing discussion. A single comment from someone saying your article helped them can mean more than hundreds of extra reactions. Some of my favorite articles haven't necessarily been my most popular ones, and that's completely okay.

These days, I still look at my article stats because I think it's natural to be curious, but they no longer decide whether I consider an article a success. What matters more is whether I enjoyed writing it, whether I learned something through the process, and whether it started a meaningful conversation.

One example of this for me is Dev Opportunity Radar. When I first started the series, I'll admit I hoped it would reach more people than it has so far. There are weeks where I wish it had more views because I believe these opportunities could help more developers. Maybe there are things I can improve, and I'm always trying to learn.

But I've realized something more important: I can't let those numbers decide whether I keep showing up every Friday.

I started Dev Opportunity Radar because I kept discovering amazing fellowships, grants, hackathons, and resources after it was already too late to apply. I didn't want other people to miss those opportunities for the same reason. That purpose hasn't changed just because a particular edition gets fewer views than I hoped.

What's interesting is that the numbers only tell part of the story. If you only looked at the view count, you might think the series isn't doing particularly well. But when I read the comments, it's a completely different picture. People share opportunities I would have never found on my own. They celebrate getting accepted into programs. They suggest improvements, contribute Community Finds, and tell me an edition helped them discover something they would have otherwise missed.

That reminds me that impact isn't always measured by views or reactions. Sometimes it's measured by the conversations you start and the people you help, even when those numbers aren't immediately visible.

Dev Opportunity Radar has changed me more than I expected.

It gave me a reason to show up every Friday and helped me find a place in the community that feels uniquely my own.

Even if only a handful of people read each edition, that's still a handful of people I have the chance to help, and to me, that's reason enough to keep going.

Lesson 4: Your Voice Will Change

One of the biggest misconceptions I had when I started writing was that I needed to figure out my writing style before I could become a consistent writer. I don't think that's how it works at all.

I think you discover your voice by writing. Every article teaches you something new about how you think, what you enjoy writing about, and how you connect with readers. As you keep writing, your confidence grows, your ideas become clearer, and you slowly begin to understand what feels authentic to you.

When I look back at some of my earlier articles, I can already see changes in the way I write. Some things I'd explain differently today, and there are ideas I'd probably approach from a different angle. I don't see that as a bad thing. If anything, it's a sign that I'm learning.

Even today, I don't think I've found my final writing voice, and honestly, I hope I never fully do. I hope it continues to evolve as I learn new things, meet new people, and gain new experiences. To me, that's one of the most exciting parts of writing. Every article becomes another small step in that journey.

So if you're just starting out, don't put too much pressure on yourself to find your "voice" before you begin. Start writing, keep showing up, and give yourself permission to grow. You might be surprised by how much your writing changes a few months from now.

Lesson 5: Write What You Can Relate To

The articles I've enjoyed writing the most all have one thing in common. They came from experiences I could genuinely relate to.

Dev Opportunity Radar is the clearest example. As I mentioned earlier, it grew out of a frustration I'd lived through myself: missing opportunities simply because I found out about them too late. The opportunity itself was rarely the problem. Access to information was.

That experience made me wonder how many other people were missing opportunities for the exact same reason. So I decided to start sharing the fellowships, grants, hackathons, and resources I came across each week, hoping someone else would discover them while there was still time to apply.

It taught me something I keep coming back to. The articles people connect with the most aren't always about the most popular topics. They're often the ones that come from experiences only you have lived, because those experiences give you a perspective nobody else can write in quite the same way.

If I could give one more piece of advice, it would be this: don't spend too much time trying to figure out what everyone else wants you to write. Instead, think about the experiences you've had, the challenges you've faced, the things you've learned, or even the problems you've wished someone had solved for you. Sometimes the best ideas come from asking yourself, "What do I wish I had known a year ago?"

That's still the reason I enjoy putting Dev Opportunity Radar together every Friday. The purpose has always been bigger than the numbers.

Lesson 6: Community Makes Ideas Better

One of the biggest surprises over the past three months is realizing that writing isn't really a solo activity. Every article may begin with one person behind a keyboard, but it rarely ends there.

Every time I press Publish, the article becomes something more because of the people who take the time to read it. Their comments make me think differently. Their questions inspire future articles. Sometimes they share their own experiences, and I end up learning just as much from them as they do from me. That's one of my favorite parts of writing on DEV: every article becomes the beginning of a conversation rather than the end of one.

Dev Opportunity Radar is probably the best example of this. I may be the one putting each edition together, but the series has never really felt like something I build alone. Community Finds was there from the very first edition because I wanted it to be a space where everyone could share opportunities, not just me. Since then, people have continued contributing opportunities I would've otherwise missed, Reader Updates have given people a chance to celebrate their own milestones, and the series has even grown into its own website. It no longer feels like just my series.

It's become something the community helps build every week, and much bigger than I could have built on my own.

Being part of that has changed me in ways I never expected. It's introduced me to incredible people and given me a place in this community that feels uniquely my own.

More than anything else, these past three months have reminded me that communities grow because people choose to contribute in their own way. Some write articles. Some leave thoughtful comments. Some answer questions, share opportunities, or simply encourage someone who's just getting started. Every one of those contributions matters, and together they create the kind of community people want to come back to.

A few people deserve a special mention here. @webdeveloperhyper, @klaudiagrz, @francistrdev, @javz, @technogamerz, @xulingfeng, @csm18, @itsugo and @shubhradev, thank you for always supporting me. On so many of my posts, you show up with a reaction or a comment, and it means a lot every single time. You've become friends at this point, and I always look forward to seeing you around the community.

I know I won't be able to name everyone who's supported me, and there are honestly so many more people who've been part of this in ways big and small. If I've missed your name, please don't take it personally. It's not intentional, and I'm just as grateful to you as to anyone I've named.

And to everyone else who's followed along and kept supporting my work, thank you. Whether you follow me here on DEV, read one article or all 25, left a comment, hit react, or simply read quietly without saying a word, that support means just as much to me. A reaction on a day I wasn't sure about an article has meant just as much as a comment or a message. You've helped shape my experience on DEV far more than you probably realize.

Lesson 7: It's Okay to Take a Break

One thing I've learned over the past three months is that it's okay to take a step back every now and then.

Last week was actually the first week in a while where I didn't publish a new article, apart from Dev Opportunity Radar. It wasn't because I had run out of ideas or because I didn't want to write.

I simply didn't have a topic that I genuinely felt excited about, and I didn't want to force one just for the sake of staying consistent.

If you're just getting started, I do think it helps to have a gentle goal. Maybe that's one article a week or even one every couple of weeks. Having a small target can help you build a routine without making writing feel like another obligation.

That said, I don't think every goal has to be followed perfectly. I usually aim to publish one article a week (apart from Dev Opportunity Radar), but if I don't have an idea that genuinely excites me, I'd rather wait than force something just to stay on schedule. In my experience, the more you write, read, and interact with the community, the more ideas naturally start to appear.

I think there's a lot of pressure online to always be creating, always publishing, and always staying visible. For me, writing has always been something I look forward to, and I'd like to keep it that way.

At the end of the day, we're all human. The hobbies, passions, and projects we care about shouldn't become another source of burnout. If taking a short break means coming back with more excitement and fresh ideas, that's a much healthier approach than forcing yourself to create something your heart isn't really in.

Final Thoughts

Three months ago, I simply wanted to become a better writer. I realize now I gained much more than that.

I became a little more confident every time I pressed Publish, discovered topics I genuinely enjoy writing about, found a community that constantly inspires me, and watched a small idea born from one of my own frustrations grow into something much bigger than I ever imagined.

If there's one thing these past three months have taught me, it's that writing is about so much more than publishing articles. It's about sharing experiences, learning from one another, and becoming part of a community where people genuinely want to see each other succeed. Some of the best parts of this journey didn't begin when I clicked Publish. They began when someone replied, shared their perspective, or simply started a conversation.

I don't know what the next three months will look like, and I hope they surprise me just as much as the last three have. I'm sure my writing will continue to evolve, my interests will change, and hopefully I'll keep finding new ways to contribute to this amazing community.

For now, I'm simply grateful that I decided to press Publish on that first article.

Ask Me Anything 💙

If you've made it this far, thank you so much for reading. Writing these articles has taught me a lot, but one of my favorite parts has always been the conversations that happen after I press Publish, so it felt fitting to end this reflection with a conversation too.

Everything I've shared here simply comes from my own experiences over the past few months, and I'm sure there's plenty I still have to learn. So if you're new to DEV, thinking about writing your first article, curious about Dev Opportunity Radar, or even feeling a little nervous about pressing Publish for the first time, feel free to ask me anything. Writing, finding ideas, building a series, engaging with the community, or anything else on your mind. If I know the answer, I'll share it. If I don't, I'll be honest about that too.

I'd also love to hear about your own journey. A lesson you've learned, a tip that's helped you, or something you're excited or nervous about if you're just starting out.

My hope is that the comments become more than a Q&A between you and me, a place where everyone shares stories and lessons that might help someone else just beginning their own.

I'm looking forward to chatting with all of you down there 💙

🤝 Let's Stay Connected

Place	Find me here
GitHub	building things → hemapriya-kanagala
LinkedIn	resources & updates → hemapriya-kanagala
X	random dev thoughts → @KanagalaHema

Dev Opportunity Radar #9: A Fully Funded AI Security Residency, SF Founder Residency, Figma Campus Leaders & More

Hemapriya Kanagala — Fri, 24 Jul 2026 14:06:55 +0000

TL;DR

Welcome back to Dev Opportunity Radar.

This is a weekly series where I share opportunities, resources, communities, and interesting finds that I come across, with the goal of helping people discover things they might otherwise miss.

This week's edition features The Bridge by Entrepreneurs First, the Frontier AI Security Residency, the Figma Campus Leader Program 2026–2027, and The Missing Semester of Your CS Education, a free MIT course on the tools, workflows, and developer skills that every programmer should know.

If you're new to the series, you can now browse previous editions, search past opportunities, and explore Community Finds and Reader Updates on the Dev Opportunity Radar website. I've also written a short post about why I built it. You'll find links to both at the end of this article.

If you've discovered something through the radar, I'd love to hear about it. Whether you applied to an opportunity, joined a community, or found a resource you hadn't seen before, I'd be happy to feature your experience in a future 💙 Reader Updates section (with your permission).

And if you've come across an opportunity, resource, community, program, or event that deserves more attention, feel free to share it in the comments.

If I feature one of your Community Finds in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

⚡ Quick Scan
🔄 Still Open From Previous Editions
📍 This Week's Opportunities
- 📌 The Bridge by Entrepreneurs First
- 📌 Frontier AI Security Residency
- 📌 Figma Campus Leader Program 2026–2027
📚 Resources Worth Checking Out
- The Missing Semester of Your CS Education
🌟 Community Finds
- CALEC Volunteer and Internship Opportunities
💙 Reader Updates
- ⭐ This Week's Reader Spotlight
- 💬 Share Your Story
👋 Until Next Friday
🌐 Dev Opportunity Radar Website

⚡ Quick Scan

Opportunities

Opportunity	Organization	Type	Deadline
The Bridge	Entrepreneurs First	Founder Residency	August 30
Frontier AI Security Residency	ERA	AI Security Research & Engineering Residency	August 2
Figma Campus Leader Program 2026–2027	Figma	Student Leadership Program	August 2

Resource Highlight

Resource	Why Check It Out
The Missing Semester of Your CS Education	Free MIT course covering Git, shell, debugging, AI-assisted development, and the developer tools every programmer should know.

Community Find

Shared By	Find	Type	Format
Francis (@francistrdev)	CALEC Volunteer & Internship Opportunities	Volunteer & Internship Opportunities	Remote

📝 A quick note: I spend a lot of time researching and verifying every opportunity before featuring it in Dev Opportunity Radar. However, deadlines, eligibility, program details, and application requirements can change after publication. Before applying, please take a few minutes to visit the official program page, review the latest information, and confirm that you're eligible.

🔄 Still Open From Previous Editions

Before we get into this week's opportunities, here are a few from previous editions that are still accepting applications.

Opportunity	Organization	Type	Deadline	Featured In
FR8	FR8	Builder Residency	Rolling	Edition #2
Anthropic Fellows Program	Anthropic	AI Research Fellowship	Rolling	Edition #4
Sentient Open Source AGI Grant Program	Sentient Foundation	AI Grant & Investment	Rolling	Edition #6
Solo Grants	Solo Grants	Microgrant for Solo Builders	Rolling	Edition #7
Claude for Open Source	Anthropic	Open Source Program	Rolling	Edition #7
The Residency	The Residency	Deep-Tech Founder Residency	July 31	Edition #8
AIAF Fellowship 2026	AIAF × AE Studio	AI Research Fellowship	August 17	Edition #8

📍 This Week's Opportunities

Here are a few opportunities I came across this week that I thought were worth sharing.

📌 The Bridge by Entrepreneurs First

Who it's for: Ambitious founders, engineers, researchers, product builders, and future startup CEOs based outside the US who want to build a venture-scale company. You don't need to have a co-founder or even a startup idea before applying.

What stands out: The Bridge is an 8-week, fully funded residency in San Francisco designed for exceptional international founders at the very beginning of their startup journey. Participants live and build together, explore ideas, meet potential co-founders, talk to users, and receive hands-on support from the Entrepreneurs First team.

I wanted to include this because most founder programs expect you to already have a company, traction, or a complete founding team. The Bridge is different. It's designed for people who are still figuring out what to build and who to build it with, while giving them the environment and support to make meaningful progress.

Another thing I like is that the residency is only the beginning. At the end of the eight weeks, teams that demonstrate strong potential can pitch to EF's Investment Committee. Selected teams receive a $250,000 pre-seed investment (in exchange for equity) and continue building in San Francisco for another three months with ongoing support from the EF team.

Duration: 8-week residency (plus an additional 3-month company-building program for funded teams)

Location: San Francisco, California

Cost: Free (housing, workspace, food, and the program are covered)

Who can apply: Exceptional founders based outside the US. You don't need an idea or a co-founder to apply.

Application Deadline: August 30, 2026

🔗 Learn More | 🔗 Apply

📌 Frontier AI Security Residency

Who it's for: Security engineers, cybersecurity professionals, hardware and embedded systems specialists, cryptography researchers, AI safety practitioners, and experienced software engineers interested in securing frontier AI systems. Prior research experience is helpful but not required, though the applied track generally expects around five or more years of industry experience.

What stands out: The Frontier AI Security Residency (FASR) is an 8-week, fully funded, in-person research and engineering residency in Cambridge, UK, run by ERA. Residents work on real-world challenges at the intersection of AI security, cybersecurity, and hardware verification, tackling problems such as securing frontier AI systems, verifying AI compute, and building mechanisms that make AI systems more trustworthy and verifiable.

I wanted to include this because most AI programs focus on building more capable models. This residency focuses on something just as important but discussed far less often: making advanced AI systems secure, verifiable, and resilient before their capabilities outpace our ability to protect them. If you're interested in the security side of AI rather than model development, opportunities like this are still relatively rare.

Another thing I like is how comprehensive the support is. The residency covers travel, accommodation, visas, workspace, and meals during working hours, pairs each resident with an experienced mentor and a Research Manager, and culminates in a research symposium where participants present their work. Residents also receive a pro-rated salary (based on an annual rate of £34,125), making it possible to focus entirely on the research without worrying about day-to-day expenses.

Duration: 8 weeks (October 12 – December 4, 2026)

Location: Cambridge, UK (primarily in person)

Funding: Fully funded, including travel, accommodation, visa support, workspace, and meals during working hours. Residents also receive a pro-rated salary.

Who can apply: Applicants worldwide aged 18 or older. The program values demonstrated technical ability over formal credentials. Prior research experience is not required, although the applied track generally expects experienced professionals.

Application Deadline: August 2, 2026

🔗 Learn More | 🔗 Apply

📌 Figma Campus Leader Program 2026–2027

Who it's for: University and college students in the United States, Canada, and India who have at least one academic year remaining, actively use Figma, and enjoy building communities around design, creativity, and product development. Students from any major are welcome.

What stands out: The Figma Campus Leader Program gives students the opportunity to become the official Figma ambassadors at their university. Campus Leaders work with the Figma for Education team to grow their campus design community by hosting workshops, events, and creative programs while helping other students learn and use Figma.

I wanted to include this because it's more than a typical campus ambassador program. Rather than focusing on promotion alone, it gives students the resources to build a lasting design community at their university while developing leadership, event planning, and community-building experience that carries well beyond college.

Another thing I like is that India is joining the program for the first time this year, making this a great opportunity for Indian students who previously weren't eligible. Campus Leaders also receive a community budget for events, exclusive mentorship and training, direct access to the Figma team, custom Figma swag, and a complimentary ticket to Config, Figma's annual conference for product builders.

Program Duration: August 2026 – June 2027

Time Commitment: Approximately 2–5 hours per week

Benefits: Community budget, Config ticket, exclusive swag, mentorship, portfolio reviews, training workshops, and direct access to the Figma team.

Who can apply: Students in the United States, Canada, and India with at least one academic year remaining who are active Figma users and passionate about design, creativity, and community building.

Application Deadline: August 2, 2026 (11:59 PM PDT)

🔗 Learn More | 🔗 Apply

📚 Resources Worth Checking Out

Not every useful find comes with an application deadline.

Here's one resource worth checking out this week.

The Missing Semester of Your CS Education

Who it's for: Computer science students, self-taught developers, early-career software engineers, and anyone who wants to become more confident with the tools they use every day while building software.

What stands out: Every computer science degree teaches things like algorithms, operating systems, databases, and programming languages. But very few teach you how to use the tools you'll spend hours with every single day. That's exactly what The Missing Semester of Your CS Education, created by instructors at MIT, is all about. Instead of focusing on another programming language or framework, the course covers practical topics like the command line, Git, debugging, development environments, SSH, code quality, documentation, packaging, and modern AI-assisted development workflows.

I wanted to include this because I think it's one of those resources that's easy to overlook. We spend so much time trying to learn the latest framework, library, or AI tool that we sometimes forget the skills that make us more productive no matter what we're building.

One thing I really liked is how practical the course is. It's full of the little things experienced developers often take for granted but that can make a huge difference once you learn them. If you've ever wondered how someone is so fast with Git, the terminal, debugging, or navigating a large codebase, there's a good chance they've picked up many of the skills this course teaches.

I also like that the course has continued to evolve alongside the software industry. The latest edition introduces Agentic Coding and naturally incorporates AI-assisted development throughout the lectures, while still emphasizing the fundamentals that every developer should know.

Topics Covered: Shell, development environments, debugging, Git, packaging, code quality, AI-assisted development, documentation, and more.

Cost: Free

Format: Online lectures, notes, and exercises

🔗 Learn More

🌟 Community Finds

One of my favorite things about this series has been seeing people share opportunities, communities, and resources that others might not have discovered otherwise.

CALEC Volunteer and Internship Opportunities

🔗 Francis' post

🔗 CALEC Volunteer & Internship Opportunities | 🔗 Edition #6

Thank you to Francis (@francistrdev) for thinking of the radar and sharing this with the community. It really means a lot 💙

I'd love for this section to keep growing.

If you've come across an opportunity, fellowship, grant, hackathon, conference, community, resource, or anything else you think more people should know about, feel free to share it in the comments.

If I feature it in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

One small request: If you're sharing an opportunity, please avoid posting raw URLs directly in the comments. DEV sometimes filters them before I get a chance to see them.

A short description alongside the link makes it much easier for me to review and potentially feature it in a future edition.

💙 Reader Updates

One of my favorite parts of this series is seeing where the opportunities end up. This section is all about celebrating those stories.

⭐ This Week's Reader Spotlight

One of my favorite moments this week came from @anhmtk, who shared that they discovered OpenAI Build Week through Dev Opportunity Radar and were able to submit before the deadline.

They built AgentShare Live-Tester for the Developer Tools track, an OpenClaw workspace agent, and even shared one of the biggest lessons they learned while building. They found that Prompt Caching becomes much more cost-effective once the static prompt exceeds roughly 1,024 tokens, making autonomous agent workflows much cheaper to run.

If you're curious about what they built, you can also check out their Devpost submission.

Seeing readers discover an opportunity, build something, and then come back to share what they learned is exactly what I hoped this series would become.

I always enjoy when readers come back to share not just what they built, but what they learned along the way. Those little lessons often end up helping other developers too.

Thank you, @anhmtk, for sharing your journey and for letting me feature it here. Wishing you the very best with the judging. I'll be rooting for you!

💬 Share Your Story

I'd love for this section to keep growing over time.

If you discovered an opportunity through Dev Opportunity Radar, applied to something, joined a community, attended an event, or simply found a resource you hadn't seen before, I'd genuinely love to hear about it.

You don't need to have been accepted or have a big success story to share. Sometimes simply discovering the right opportunity at the right time is already a win.

I hope this section gradually becomes a place where we can celebrate those stories together, one update at a time.

👋 Until Next Friday

Before I go, I just want to say thank you.

The goal has always been simple:

Help people discover opportunities they otherwise might have missed.

Thanks to all of you, it feels like we're doing exactly that.

Thank you for reading, for sharing, and for helping make this our radar, not just mine.

I'll be back next Friday with more opportunities, resources, and Community Finds.

Until then, take care, and I hope you discover something amazing this week 💙

🌐 Dev Opportunity Radar Website

👉 Website

I also wrote a short post about why I built the website and the journey behind it.

👉 Website Launch Post

Dev Opportunity Radar #8: $100K OpenAI Build Week, $12K AI Fellowship, Founder Residency & Free AI Dev Course

Hemapriya Kanagala — Fri, 17 Jul 2026 17:11:03 +0000

TL;DR

Welcome back to Dev Opportunity Radar.

This is a weekly series where I share opportunities, resources, communities, and interesting finds that I come across, with the goal of helping people discover things they might otherwise miss.

This week's edition features OpenAI Build Week, the AIAF Fellowship 2026, The Residency for ambitious deep-tech founders, and AI Dev Tools Zoomcamp, a free hands-on course on AI-native software engineering.

Before we dive in, I wanted to share a small milestone. Dev Opportunity Radar now has its own website 🎉

It makes it easier to browse previous editions, search past opportunities, and explore Community Finds and Reader Updates. I also wrote a short post about why I built it. You'll find links to both at the end of this article.

If you've discovered something through the radar, I'd love to hear about it. With your permission, I may feature your experience in a future 💙 Reader Updates section.

And if you've come across an opportunity, resource, community, program, or event that deserves more attention, feel free to share it in the comments.

If I feature one of your Community Finds in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

⚡ Quick Scan
🔄 Still Open From Previous Editions
📍This Week's Opportunities
- 📌 OpenAI Build Week
- 📌 AIAF Fellowship 2026
- 📌 The Residency
📚 Resources Worth Checking Out
- AI Dev Tools Zoomcamp
🌟 Community Finds
- CALEC Volunteer and Internship Opportunities
💙 Reader Updates
👋 Until Next Friday
🌐 Dev Opportunity Radar Website

⚡ Quick Scan

Opportunities

Opportunity	Organization	Type	Deadline
OpenAI Build Week	OpenAI × Devpost	AI Hackathon	July 22
AIAF Fellowship 2026	AIAF × AE Studio	AI Research Fellowship	August 17
The Residency	The Residency	Deep-Tech Founder Residency	July 31

Resource Highlight

Resource	Type
AI Dev Tools Zoomcamp	Free, hands-on course on AI-native software engineering using modern AI developer tools and coding agents (Live cohort starts August 31)

Community Find

Shared By	Find	Type	Format
Francis (@francistrdev)	CALEC Volunteer & Internship Opportunities	Volunteer & Internship Opportunities	Remote

📝 A quick note: I spend a lot of time researching and verifying every opportunity before featuring it in Dev Opportunity Radar. However, deadlines, eligibility, program details, and application requirements can change after publication. Before applying, please take a few minutes to check the official program page for the latest information and confirm that you're eligible.

🔄 Still Open From Previous Editions

Before we get into this week's opportunities, here are a few from previous editions that are still accepting applications.

Opportunity	Organization	Type	Deadline	Featured In
FR8	FR8	Builder Residency	Rolling	Edition #2
Anthropic Fellows Program	Anthropic	AI Research Fellowship	Rolling	Edition #4
Sentient Open Source AGI Grant Program	Sentient Foundation	AI Grant & Investment	Rolling	Edition #6
Solo Grants	Solo Grants	Microgrant for Solo Builders	Rolling	Edition #7
Claude for Open Source	Anthropic	Open Source Program	Rolling	Edition #7

📍 This Week's Opportunities

Here are a few opportunities I came across this week that I thought were worth sharing.

📌 OpenAI Build Week

Who it's for: Developers, builders, students, and teams interested in creating AI-powered applications using GPT-5.6 and Codex. Whether you're building a consumer app, developer tool, workflow, or educational project, there's a track for a wide range of ideas.

What stands out: OpenAI Build Week is a global online hackathon centered around building with GPT-5.6 and Codex, the coding agent now available in ChatGPT. Participants receive free Codex credits (subject to the registration timeline), build a working project, and submit it across one of four tracks: Apps for Your Life, Work & Productivity, Developer Tools, or Education.

I wanted to include this because it isn't just another hackathon with cash prizes. It's an opportunity to experiment with OpenAI's latest developer tools, build something end-to-end, and showcase your work to engineers and product teams working on the platform itself.

Another thing I like is that submissions require more than just working code. Participants are encouraged to explain their technical decisions, document how they used Codex and GPT-5.6, provide a public repository, and include a demo video, making it a great exercise in both engineering and communication.

Tracks: Apps for Your Life, Work & Productivity, Developer Tools, Education

Prize Pool: $100,000

Who can participate: Eligible participants from supported countries and territories who have reached the legal age of majority in their country of residence.

Submission Deadline: July 22, 2026

🔗 Learn More & Register

📌 AIAF Fellowship 2026

Who it's for: Developers, researchers, graduate students, and independent ML practitioners with a strong technical background who are interested in AI alignment research. Applicants should be comfortable implementing machine learning experiments, working independently, and have demonstrated research experience through projects, papers, hackathons, or similar work.

What stands out: The AIAF Fellowship is an 8-week, fully remote, full-time research program run by AIAF in partnership with AE Studio. Selected fellows receive a $12,000 stipend, cloud compute resources, mentorship from experienced AI alignment researchers, and the opportunity to work on real technical research problems rather than predefined coursework.

I wanted to include this because fellowships focused on AI alignment are still relatively uncommon, especially ones that combine structured mentorship, industry-style research practices, and financial support. Rather than completing isolated exercises, fellows contribute to active research directions alongside dedicated research managers and experienced researchers.

Another thing I like is that the program places a strong emphasis on producing tangible research outputs. Each team works toward publishing a LessWrong post and, where appropriate, a research paper, before presenting their work during a Demo Day at the end of the fellowship.

Stipend: $12,000

Duration: 8 weeks (Full-time)

Format: Fully remote (Hybrid Demo Day in Los Angeles with travel covered for attendees)

Who can apply: Applicants from any country with strong machine learning skills and a genuine interest in technical AI alignment research.

Application Deadline: August 17, 2026 (AoE)

🔗 Learn More | 🔗 Apply

📌 The Residency

Who it's for: Founders, researchers, and ambitious builders working on deep-tech ideas who want to spend several months focused full-time on building alongside a community of like-minded people. Applicants should be ready to commit full-time, as the residency is not designed to be completed alongside school or a full-time job.

What stands out: The Residency is a 3-month, in-person founder residency that provides housing, coworking space, mentorship, and a community of builders so participants can focus entirely on their projects. The upcoming Fall 2026 cohort also includes up to $50,000 in compute credits, legal and immigration support, wellness resources, and a dedicated venture partner.

I wanted to include this because it's designed around something many founders struggle with: finding uninterrupted time to build. Instead of offering only funding or mentorship, the residency aims to remove many of the practical distractions by taking care of housing and day-to-day logistics while surrounding participants with other ambitious builders.

Another thing I like is its emphasis on community. Beyond mentorship and resources, the program encourages collaboration through shared living, weekly coaching sessions, Demo Day, and introductions to experienced founders and investors. It feels less like a traditional accelerator and more like an environment built for people who want to spend a season going all-in on a difficult problem.

Duration: Approximately 3 months

Format: In person

What's included: Housing, coworking space, mentorship, up to $50,000 in compute credits, legal and immigration support, wellness resources, and Demo Day opportunities.

Who can apply: Founders, researchers, and builders working on ambitious deep-tech projects.

Application Deadline: July 31, 2026

🔗 Learn More | 🔗 Apply

📚 Resources Worth Checking Out

Not every useful find comes with an application deadline.

Here's one resource worth checking out this week.

AI Dev Tools Zoomcamp

Who it's for: Developers, software engineers, data professionals, and technical students who already have basic programming experience and want to learn how to use modern AI coding tools as part of a disciplined software development workflow.

What stands out: AI Dev Tools Zoomcamp is a free, hands-on course that focuses on practical AI-assisted software engineering. Rather than teaching prompt engineering or model training, it covers real development workflows, from planning and coding to testing, deployment, security, and CI/CD, using modern AI developer tools and coding agents.

I wanted to include this because it takes a very practical approach to AI-assisted development. Instead of treating AI as a replacement for software engineering, the course emphasizes using AI responsibly while maintaining engineering discipline through code reviews, testing, documentation, and deployment.

Another thing I like is that you can complete the course in two different ways. You can learn at your own pace using all of the free materials, or join the live cohort, which starts August 31, 2026.

The live cohort doesn't mean sitting through live lectures. The lessons are still pre-recorded. What makes it different is the structured experience: shared deadlines, graded homework, peer review, a leaderboard, community support, and eligibility for a certificate after completing the final project. If you're someone who learns better with accountability and a community of learners, the live cohort offers a more engaging experience than simply watching videos on your own.

By the end of the course, you'll build and deploy your own AI-assisted software project while learning modern development practices around coding agents, MCP, testing, Docker, CI/CD, deployment, security, and documentation.

Cost: Free

Format: Online

Live Cohort Starts: August 31, 2026

Best for: Developers who want practical experience using AI coding tools in real software engineering workflows.

🔗 Learn More | 🔗 Live Cohort Registration

🌟 Community Finds

One of my favorite things about this series has been seeing people share opportunities, communities, and resources that others might not have discovered otherwise.

CALEC Volunteer and Internship Opportunities

🔗 Francis' post

🔗 CALEC Volunteer & Internship Opportunities | 🔗 Edition #6

Thank you to Francis (@francistrdev) for thinking of the radar and sharing this with the community. It really means a lot 💙

I'd love for this section to keep growing.

If you've come across an opportunity, fellowship, grant, hackathon, conference, community, resource, or anything else you think more people should know about, feel free to share it in the comments.

If I feature it in a future edition, I'll always make sure to credit you. If you discovered it, that recognition belongs to you.

One small request: If you're sharing an opportunity, please avoid posting raw URLs directly in the comments. DEV sometimes filters them before I get a chance to see them.

A short description alongside the link makes it much easier for me to review and potentially feature it in a future edition.

💙 Reader Updates

I'm looking forward to this section gradually growing over time, and I'd still love to hear from you.

One of my favorite parts of writing Dev Opportunity Radar has been hearing from people who discovered something they otherwise might have missed.

You don't need to have been accepted or have a big success story to share. Sometimes simply discovering the right opportunity at the right time is already a win.

I hope this section gradually becomes a place where we can celebrate those stories together, one update at a time.

👋 Until Next Friday

Before I go, I just want to say thank you.

When I published the very first edition of Dev Opportunity Radar, I simply hoped it would help a few people discover opportunities they might otherwise have missed.

Eight editions later, the series has grown into something I never imagined when I published that first edition. What started as a weekly series has gradually grown into a community project, and this week, that journey reached another small milestone with the launch of the Dev Opportunity Radar website.

That milestone wouldn't have happened without this community.

From the very beginning, you've shared opportunities, suggested resources, contributed Community Finds, celebrated each other's wins, and encouraged me to keep the series going. Every comment, suggestion, and kind message has helped shape Dev Opportunity Radar into what it is today.

I also want to say a special thank you to the DEV Community. This series has always been supported by the community here, and without that support, it simply wouldn't exist in the way it does today. Whether you've been here since the first edition or just discovered the series today, thank you for being part of the journey. It truly means a lot.

One of my favorite things about this series is seeing it become more collaborative with every edition. Community Finds and Reader Updates remind me that this isn't just about sharing opportunities. It's about celebrating discoveries, learning from one another, and helping more people discover things they might otherwise have missed.

The goal of this series hasn't changed:

Help people discover opportunities they otherwise might have missed.

My hope is that, with every edition, we help a few more people discover the opportunity that could make a difference for them.

Thank you for reading, for sharing, and for helping make this our radar, not just mine.

Here's to many more editions, many more opportunities, and many more people discovering them.

I'll be back next Friday with more opportunities, resources, and Community Finds.

See you next Friday 👋

🌐 Dev Opportunity Radar Website

👉 Website

I also wrote a short post about why I built the website and the journey behind it.

👉 Website Launch Post