DEV Community: Aksa Fatima

The Art of Doing Less, Learning More

Aksa Fatima — Sun, 25 Oct 2026 06:45:50 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

As a student and developer, I know how time-consuming studying can be. Sometimes, understanding the material isn't even the hardest part. Going through long notes, making summaries, preparing questions, and planning revision can take up a lot of time before you actually get to learning.

That got me thinking: what if I could bring some of these tasks together in one simple tool?

That's how I started building StudySloth, an AI-powered study assistant built with Python and Streamlit.

The idea behind the name is simple: studying takes effort, but organizing your study material shouldn't have to take so much of it!

StudySloth is designed to help turn study material into useful learning resources, including:

Summaries to make lengthy notes easier to review.
Flashcards to support active recall and revision.
Quizzes to help students test their understanding.
Revision plans to help organize what to study next.
PDF support so students can work with their existing study material.

Instead of switching between different tools for each task, the goal is to make the process more convenient from one place.

This project is still a work in progress, but building it has given me an opportunity to explore how AI can be used to solve everyday problems in a practical way.

Demo

I'm sharing a walkthrough of StudySloth to show how the application works, from providing study material to generating learning resources.

🎥 Video demo:

If you'd like to try the project yourself, check out the code below.

Code

💻 GitHub repository:

AKSA119 / StudySloth

AI-powered study assistant built with Streamlit

StudySloth 🦥

Less Stress. More Learning. A cloud-ready study assistant powered by open-weight AI.

StudySloth turns study material into a chapter summary, flashcards, multiple-choice quizzes, and a short revision plan.

Features

Upload a text-based PDF or paste notes.
Generate a summary, flashcards, quiz questions, and revision tasks.
Try a fully working demo mode without an API key.
Connect a hosted OpenAI-compatible inference endpoint and an open-weight model.
Download the summary as Markdown or the full pack as JSON.
Quiz scoring and answer explanations.
Streamlit interface with notes, flashcards, quizzes, revision plan, and settings.

Requirements

Python 3.10 or newer
Internet access for installing dependencies and for live hosted inference
An API key from a compatible hosted inference provider for live AI (demo mode does not require one)

Run locally

# Windows
py -m venv .venv
.venv\Scripts\activate
pip install -r requirements.txt
streamlit run app.py

# macOS / Linux

…

View on GitHub

The project is built primarily with Python and Streamlit, with PDF text extraction and an AI API integration powering its main workflow.

Feel free to explore the code, share feedback, or suggest improvements. I'm always looking for ways to make the project more useful.

How I Built It

I built StudySloth using Python for the application logic and Streamlit for the user interface.

I wanted to keep the interface straightforward so that users could focus on their study material rather than spend time figuring out how the application works.

Some of the main parts of the project include:

Streamlit: For building the interactive web interface.
Python: For handling the application's logic and processing study material.
PDF text extraction: Using pypdf to extract text from uploaded documents.
AI integration: Using an OpenAI-compatible API to send study material to an AI model and generate structured learning content.
JSON processing: To parse and organize the generated summaries, flashcards, quizzes, and revision plans for use in the application.

One challenge was working with the limitations of AI APIs, particularly request-size and token limits. Long study materials can require more tokens than a model's available rate limits allow, so managing the amount of input and output became an important part of making the application more reliable.

It reminded me that building an AI application isn't just about sending a prompt to a model. You also have to think about how the data is handled, how responses are structured, and what happens when something goes wrong.

For the AI component, I'm using an open-weight model through an API-compatible service. This lets me experiment with models and build around their capabilities without having to train a model from scratch.

Why Does Open Innovation Matter?

For me, open innovation matters because it makes experimenting and learning much more accessible.

As someone building projects and improving my development skills, having access to open-source tools such as Python, Streamlit, and PDF-processing libraries makes a real difference. I can inspect how things work, combine different technologies, and build something useful without needing to create every component myself.

Open-weight AI models also make it possible to explore different approaches to AI-powered applications. Developers can compare models, experiment with prompts, and choose an approach that fits their needs and constraints.

There are still practical considerations, of course. Using a model through an API can involve rate limits, service restrictions, and costs. Open-weight models don't automatically mean that every part of an application is free or open source.

But the wider ecosystem gives developers more options and more opportunities to learn.

That's one of the things I appreciate most about this space: you can start with a simple idea, use tools built by the community, and gradually turn that idea into a working project.

My Agent Session

I don't have a public agent session to share yet.

If I publish a session using DevRelay for this project, I'll add the link here.

The Lazy Payoff

The goal of StudySloth is to reduce the repetitive work that comes with preparing for a study session.

Think about the usual process: read a chapter, write a summary, create flashcards, prepare practice questions, and decide what to revise next. StudySloth aims to bring those steps together and automate part of that preparation.

I haven't measured the exact amount of time saved yet, so I won't claim a specific number. For now, the focus is on building a workflow that makes study preparation simpler and more organized.

After all, being a little lazy about repetitive tasks can sometimes leave you with more time for the work that actually matters. 😄

Prize Categories

[Add the Hacktoberfest partner prize categories that apply to your submission, after checking the challenge rules.]

Final Thoughts

StudySloth started with a simple idea: make studying a little easier with the help of AI.

Building it has taught me that even a relatively small project involves much more than writing code. There are design decisions, API limitations, data handling, debugging, and plenty of small improvements along the way.

It isn't a finished product, and there's still a lot I'd like to improve. But I think that's part of the fun of building things: you learn by making something, testing it, finding problems, and trying again.

I'm glad to share StudySloth as part of the Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady.

I'd love to hear your thoughts!

What feature would you add to an AI-powered study assistant?

Ledgerly: A Private, Local-First Receipt and Invoice Assistant

Aksa Fatima — Sun, 18 Oct 2026 14:33:08 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built
Ledgerly is a local-first receipt and invoice assistant for freelancers, small businesses, and anyone who wants a clearer view of their spending without sending financial documents to a cloud AI service.

Users can upload a receipt or invoice as a JPG, PNG, or PDF. Ledgerly extracts the document text in the browser, sends only that extracted text to a locally running open-weight Phi-3.5 Mini model, and converts the result into structured financial fields such as:

Vendor or company name
Invoice and transaction dates
Customer and billing details
Line items
Quantities and prices
Subtotal
Tax
Total amount
Payment method and notes
The extracted information is then presented in a modern finance dashboard for quick review and organization.

The people most likely to pay for Ledgerly are freelancers, independent contractors, small-business owners, and bookkeepers who need lightweight expense tracking but do not want to manually enter every receipt or upload sensitive documents to a third-party AI API.

Demo
Live demo:

vercel.com

A useful demo flow is:

Open Ledgerly.
Choose the built-in sample invoice or upload a receipt image.
Let the browser perform OCR or PDF text extraction.
Run local inference with Phi-3.5 Mini.
Review the structured invoice fields in the dashboard.
Code
Source code:

AKSA119 / ledgerly

How I Built It
Ledgerly is built with Next.js and React. The interface uses a dashboard-style design inspired by modern consumer finance and social applications, with strong visual hierarchy, cards, activity views, and responsive layouts.

The AI pipeline is intentionally client-side:

The user selects a JPG, PNG, or PDF.
The file is processed in the browser.
OCR or PDF text extraction produces plain text.
The extracted text is passed to Phi-3.5 Mini through WebLLM.
The model returns structured invoice data.
Ledgerly validates and displays the extracted fields for review.
The original document is not uploaded to a remote AI endpoint. This keeps the prototype privacy-focused and demonstrates that useful document intelligence can run directly on a user's device.

The app also includes a built-in sample invoice so the complete workflow can be demonstrated without requiring users to find a test document online.

Why Does Open Innovation Matter?
Open innovation made it possible to build Ledgerly around a model that users can inspect, run, and control instead of depending entirely on a closed AI API.

A closed API would make the initial implementation easier, but it would require sending financial documents or their contents to an external provider. It could also introduce usage costs, vendor lock-in, rate limits, and uncertainty about how sensitive data is handled.

Using an open-weight model with WebLLM provides several important advantages:

Private, browser-based inference
No per-document AI API fee
Reduced dependence on a single provider
A transparent and reproducible technical stack
The ability to improve prompts and parsing logic independently
A practical demonstration of local AI for everyday business workflows
There are trade-offs. Browser inference requires a compatible device, model download, memory, and processing time. However, for a lightweight receipt assistant, the privacy and ownership benefits make local inference a compelling option.

Prize Categories
Ledgerly is being submitted for categories related to:

Open-source AI
Open-weight models
Local inference
AI-powered productivity tools
Privacy-focused applications
What I Would Build Next
The next version could add correction feedback, CSV and accounting exports, recurring vendor detection, receipt search, tax-category suggestions, and optional encrypted synchronization between devices.

The long-term goal is to make Ledgerly a practical personal finance tool where AI is helpful without requiring users to give up control of their financial documents.

Why Vector Search Fails at Cloud Security: Building BreachPath with FalkorDB and Autonomous Agents

Aksa Fatima — Sun, 18 Oct 2026 07:55:03 +0000

Imagine this scenario: It’s 2:00 AM, and your SOC detects that an external contractor’s laptop was compromised. His username is Dave.

You check Dave’s permissions in AWS IAM: he only has access to a couple of staging deployment scripts. He has zero direct permissions on the production Postgres database containing 500,000 customer credit card records.

According to traditional rule engines and vector-based AI assistants, you are safe.

Except you aren't.

Three hours later, your production data is dumped on the dark web. How did an unprivileged contractor bypass your security perimeter without triggering a single alarm?

This is the exact problem we set out to solve with BreachPath, an autonomous cloud security agent built for the FalkorDB Hackathon (Track 1: Agents That Act on Connected Data).

The Blind Spot: The Multi-Hop Trap

In modern cloud environments, security breaches rarely happen in a straight line. Attackers don't break through steel doors; they crawl through the vents using transitive privilege escalation:

[Dave (Contractor)]
       │ (MEMBER_OF)
       ▼
[Contractors-Dev-Group]
       │ (CAN_ASSUME)
       ▼
[StagingDeployerRole]
       │ (ATTACHED_TO)
       ▼
[CI-Runner EC2 Instance]
       │ (HAS_ACCESS_TO)
       ▼
[CI_KMS_KEY (Env Var)]
       │ (DECRYPTS)
       ▼
[ProdAdminSecret]
       │ (GRANTS_ACCESS_TO)
       ▼
[CustomerData-Postgres-Prod] 🚨 CROWN JEWEL COMPROMISED

Why Vector RAG Completely Fails Here

Many modern AI security tools rely on Vector RAG (embeddings stored in vector databases).

If you ask a Vector RAG agent: "Can Dave reach the customer database?", the embedding of "Dave" and "Customer Database" have near-zero semantic similarity. Vector search computes vector proximity in high-dimensional space—it cannot traverse relationships, compute graph reachability, or find shortest paths.

To solve connected problems, the agent needs a graph as its context layer.

Enter BreachPath: An Agent Driven by FalkorDB

Instead of bolting a database onto the side of an LLM as a passive archive, BreachPath makes FalkorDB the active cognitive layer for the agent.

We modeled our cloud infrastructure as a dynamic graph:

Nodes: IAM Users, Groups, Roles, EC2 Compute, KMS Keys, and S3/RDS Databases.
Edges: Relationships like MEMBER_OF, CAN_ASSUME, ATTACHED_TO, and DECRYPTS.

1. Multi-Hop Reasoning via Cypher Queries

When an alert triggers on Dave’s account, the agent queries FalkorDB using Cypher’s shortestPath() algorithm:

MATCH p = shortestPath((u:User {name: 'dave-contractor'})-[*1..7]->(t:Storage {classification: 'CrownJewel'}))
RETURN p

In under 4 milliseconds, FalkorDB uncovers the hidden 6-hop lateral movement chain that would have taken a human security team days of manual log-digging to find.

2. Graph Algorithms as MCP Tools

We wrapped FalkorDB’s graph algorithms into Model Context Protocol (MCP) tools:

find_attack_paths: Discovers all transitive routes to sensitive assets.
calculate_blast_radius: Uses neighborhood degree centrality to compute a numerical risk score (0 to 100) quantifying total exposure.
find_chokepoints: Performs cut-point analysis to identify the single relationship whose removal breaks the attack chain with minimum operational disruption.

3. Autonomous Remediation (Not Just Chat)

Judges and security teams don’t just want advice—they want closed-loop remediation.

Based on the graph topology, BreachPath identifies that severing the CAN_ASSUME relationship between Contractors-Dev-Group and StagingDeployerRole neutralizes the threat. The agent:

Deletes the edge directly in the live FalkorDB Cloud graph.
Auto-generates a least-privilege Terraform HCL policy to permanently enforce the fix in production.

What We Learned Building with FalkorDB

1. Graphs Must Shape Agent Decisions, Not Sit on the Side

Most AI agent projects fail because they use databases as dumb scratchpads. Putting FalkorDB at the center meant the graph’s topology dictated what the agent investigated next, which MCP tool it invoked, and when it was confident enough to take action.

2. Sub-Millisecond Latency is a Superpower

Because FalkorDB is built on top of Redis technologies, graph queries execute in single-digit milliseconds. When an agent is running iterative multi-hop traversals inside a tight reasoning loop, this low latency is the difference between an instantaneous real-time response and a frustrating timeout.

3. Deterministic Explainability Beats Black-Box Guesses

You can never tell a Chief Information Security Officer (CISO): "The LLM felt this account was suspicious."

With BreachPath and FalkorDB, every remediation decision is accompanied by the exact node-by-node audit trail. The agent can prove mathematically why a link was cut and show the visual before-and-after graph.

Try It Out

BreachPath is fully open-source with an interactive cyber-ops dashboard, live graph animations, and Web Audio effects:

📦 GitHub Repository:
AKSA119 / breachpath
🛡️ BreachPath — Autonomous Cloud Attack Path & Blast-Radius Remediator

FalkorDB Hackathon Submission
Track: Track 1: Agents That Act on Connected Data
Theme: Multi-hop reasoning, graph algorithms as tools, tool selection through MCP, autonomous remediation, and explainable results.

💡 The Problem

In modern cloud architectures (AWS/GCP/K8s), security risks are rarely a single direct vulnerability. Instead, attackers use multi-hop privilege escalation: an external contractor account with minimal permissions can assume a role, connect to a CI runner, read an unencrypted KMS key, and unlock the Crown Jewel production database.

Vector search and traditional LLMs completely fail here because:
1. They cannot compute graph reachability or transitive permissions.
2. They cannot run graph path algorithms (Shortest Path, Chokepoint analysis, Min-Cut).
3. They cannot guarantee an explainable, deterministic audit trail.
🚀 The Solution: BreachPath

BreachPath places FalkorDB at the center of the agent's context layer:
- Knowledge Graph: Maps Users, IAM Groups, Roles, EC2 Instances, KMS…
View on GitHub
🛠️ Built With: FalkorDB Cloud, Python, Vis.js, and Model Context Protocol (MCP).

If you're building AI agents, stop asking them to guess relationships—give them a graph.

AI help me to escape the one thing AI lives in — my screen.

Aksa Fatima — Sun, 11 Oct 2026 16:32:00 +0000

This is my submission for the Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass.

What I Built

We spend so much time looking at screens that sometimes we forget to look at what's around us.

A plant growing beside a road, a leaf with an unusual shape, or a tiny flower in a park can easily go unnoticed when we're busy scrolling. I wanted to build something that could make people a little more curious about the world outside.

That's how Jadi-Booti Solo came to life. 🌱

It's a nature exploration app designed to encourage people to step outside, notice plants around them, and record what they discover. You can take or upload a plant photo to try identifying it, explore plant information, keep a nature journal, and save little memories from your outdoor time. It also includes features such as voice notes and optional location-based memories.

The idea isn't to make people spend more time on another app. It's to give them a reason to put their phones down, go outside, and use technology to learn something about the real world.

It's for anyone who wants to reconnect with nature, whether that's a student taking a walk around campus, someone exploring a local park, or simply a person who wants to make their daily walk a little more interesting.

Demo

🌐 Live Demo:

The best way to experience the idea is to take a walk, find an interesting plant, and try exploring it with the app.

Code

💻 GitHub Repository:

AKSA119 / jadi-booti-solo

Jadi-Booti Solo 🌿

An AI-powered nature exploration app and botanical memory journal built for the Touch Grass Hackathon Challenge.

Touch Grass Philosophy: The screen is the shortest part of the experience. Use open AI to help people step away from devices, discover living flora in parks and neighborhoods, complete physical outdoor missions, and record place-linked memories.

🌟 The 3 Core Pillars

1. AI Plant Identification (Open-Weight Vision)

Users take a photo with their phone camera outdoors or upload a leaf/bark/flower specimen.
Analyzed via Meta Llama 3.2 Vision (llama-3.2-11b-vision-preview) hosted on high-speed Groq LPU inference.
Provides common name, botanical binomial, confidence score, leaf/bark visual characteristics, traditional ecological uses, and a clear safety uncertainty notice.
Audio narration reads out plant stories and observation notes in natural Hindi/English speech.

2. Nature Quests (Outdoor Missions)

Physical field missions that motivate users to explore the real world
- 🍃 The Tri-Leaf Hunter: Find…

View on GitHub

The project includes a web-based frontend, an Express backend, plant data, and features for plant exploration and saving nature journal entries.

I'd love for others to explore the code, try the project, and contribute ideas that could make it more useful.

How I Built It

I built Jadi-Booti Solo as a web app with a focus on keeping the experience simple and accessible.

Here's the basic setup:

Frontend: HTML, CSS, and JavaScript for the interface.
Backend: Node.js and Express for API routes and app functionality.
Plant data: A curated collection of plant information.
AI features: The app is designed to support plant identification from images and speech-to-text for voice notes.
Nature journal: Users can save observations and memories from their explorations.
Progressive web app features: A web app structure that can make the experience feel more app-like on supported devices.

One of the challenges was getting the different parts to work together, especially when moving from local development to deployment. A feature can work on your own computer and still fail online if the frontend and backend aren't connected correctly. That taught me that building a project isn't just about making the interface look good; the underlying pieces have to work together too.

I'm still working on making the deployed experience reliable, particularly the AI-powered features. I want to be honest about that rather than pretend every part is already perfect.

Why Does Open Innovation Matter?

For a project like this, open innovation matters because nature is something everyone should be able to explore, learn about, and contribute to.

Open-source tools give developers a chance to experiment, learn from existing work, and build useful things without having to create every component from scratch. Open-weight AI models also offer more flexibility to developers who want to understand how their AI features work and explore different ways to run them.

That flexibility is important for a project like Jadi-Booti Solo. AI can help people learn about plants, but the experience should remain accessible and should encourage people to observe the real plant instead of treating an AI answer as unquestionable truth.

I'd also like the project to grow through community contributions: better plant information, more regional plants, improvements to accessibility, and new nature challenges. Someone who knows more about local plants than I do could help make the project better for everyone.

That's one of the things I appreciate about open source: you don't have to build everything alone.

Final Thoughts

Jadi-Booti Solo is a small project, but the idea behind it means a lot to me.

Technology doesn't always have to keep us indoors or glued to a screen. It can also help us become more curious about the places we live in.

If this app encourages even one person to take a walk, notice a plant they would normally ignore, or learn something new about their surroundings, then I think it's doing something worthwhile.

For now, my challenge to you is simple: put your phone away for a few minutes, step outside, and see what you notice. 🌿

You might be surprised by how much you've been walking past.

Hacktoberfest #OpenSource #AI #Javascript

DriftGuard — AI Code Sanitizer & Refactor Agent Powered by Sanity Context

Aksa Fatima — Sun, 04 Oct 2026 15:44:05 +0000

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

What I Built

AI can generate code really fast.

But one problem I kept running into is that the code can look completely correct while still using an old API or outdated documentation.

That is why I built DriftGuard.

DriftGuard is an AI code auditing and refactoring agent. You give it code, and it checks that code against a structured knowledge base containing information about deprecated APIs, current versions, and their recommended replacements.

For example, if the code uses an outdated Next.js API, DriftGuard can identify the issue, explain what changed, and suggest the newer approach.

The main idea behind the project is simple:

Don't just ask an AI whether code is correct. Give it a source of truth to check against.

Demo

Here’s a short walkthrough of DriftGuard, showing how it checks code against the Sanity-powered knowledge base and identifies outdated APIs.

🎥 Demo: [https://youtu.be/3RvNo10mnC8?si=kXwCE2mkY0PN7O3m]

The demo shows the basic flow:

Code → Sanity Context → Code Rules → AI Audit → Identify outdated code → Refactor

Code

💻 GitHub Repository: [https://github.com/AKSA119/driftguard]

How I Used Sanity

This is where Sanity became an important part of the project.

Instead of keeping all the rules inside prompts or hardcoding them into the application, I created a Sanity project and modeled the coding rules as structured content.

I created a Code Rule document type with fields such as:

Technology
Version
Status
Old API / Code
Replacement
Explanation
Official Source URL
Last Verified

I added rules for things like:

Next.js 15 async request APIs
Vercel AI SDK 5 addToolResult → addToolOutput
Vercel AI SDK 6 generateObject deprecation

DriftGuard connects to the Sanity Context MCP endpoint from the backend and retrieves these rules from Sanity.

The retrieved content is then used alongside the user's code during the AI audit.

So instead of the model simply saying:

"I think this API is outdated."

it has structured information from Sanity that tells it what changed, which version it applies to, what the replacement is, and where the information came from.

That was the part of the project I found most interesting — Sanity isn't just storing content here. It is acting as the knowledge layer that the agent can actually query.

Sanity Project Details

Project ID: wam7t4lk

Dataset: production

The project contains the structured Code Rule documents used by DriftGuard.

This is also the project the Sanity team can inspect to see how I modeled the content behind the agent.

How the Agent Works

User Code
    ↓
DriftGuard
    ↓
Sanity Context MCP
    ↓
Code Rules from Sanity
    ↓
Relevant rules retrieved
    ↓
AI Code Audit
    ↓
Outdated / deprecated APIs identified
    ↓
Sanity-grounded refactoring
    ↓
Updated Code

What I Learned

The biggest thing I learned while building DriftGuard is that connecting an AI model to real, structured information changes how useful the system can be.

Getting the first demo working was actually the easy part.

The harder part was dealing with things like MCP connections, authentication, outdated model versions, API changes, and making sure the AI output followed the format the application expected.

There were definitely a few moments where something that looked like a small change turned into a debugging session. 😅

But that was also the most useful part of the build.

DriftGuard started as an idea about detecting outdated code, but it ended up teaching me a lot about how AI agents, structured content, MCP, and real-world debugging fit together.

sanitychallenge #sanity #dev #webdev

DEV Community: Aksa Fatima

The Art of Doing Less, Learning More

What I Built

Demo

Code

AKSA119 / StudySloth

AI-powered study assistant built with Streamlit

StudySloth 🦥

Features

Requirements

Run locally

How I Built It

Why Does Open Innovation Matter?

My Agent Session

The Lazy Payoff

Prize Categories

Final Thoughts

Ledgerly: A Private, Local-First Receipt and Invoice Assistant

AKSA119 / ledgerly

Why Vector Search Fails at Cloud Security: Building BreachPath with FalkorDB and Autonomous Agents

The Blind Spot: The Multi-Hop Trap

Why Vector RAG Completely Fails Here

Enter BreachPath: An Agent Driven by FalkorDB

1. Multi-Hop Reasoning via Cypher Queries

2. Graph Algorithms as MCP Tools

3. Autonomous Remediation (Not Just Chat)

What We Learned Building with FalkorDB

1. Graphs Must Shape Agent Decisions, Not Sit on the Side

2. Sub-Millisecond Latency is a Superpower

3. Deterministic Explainability Beats Black-Box Guesses

Try It Out

AKSA119 / breachpath

🛡️ BreachPath — Autonomous Cloud Attack Path & Blast-Radius Remediator

💡 The Problem

🚀 The Solution: BreachPath

AI help me to escape the one thing AI lives in — my screen.

What I Built

Demo

Code

AKSA119 / jadi-booti-solo

Jadi-Booti Solo 🌿

🌟 The 3 Core Pillars

1. AI Plant Identification (Open-Weight Vision)

2. Nature Quests (Outdoor Missions)

How I Built It

Why Does Open Innovation Matter?

Final Thoughts

Hacktoberfest #OpenSource #AI #Javascript

DriftGuard — AI Code Sanitizer & Refactor Agent Powered by Sanity Context

What I Built

Demo

Code

How I Used Sanity

Sanity Project Details

How the Agent Works

What I Learned

sanitychallenge #sanity #dev #webdev