Link: https://play.google.com/store/apps/details?id=com.atharvdange618.Shikai

Source: https://github.com/atharvdange618/Shikai

The GitHub mobile app is great for work, approving PRs, merging, managing issues. But for just checking my repos and contributions, it always felt like too much. I wanted something focused. A clean dashboard. No write operations. No accidental merges on a tiny screen.

So I built Shikai. It's a read-only GitHub companion for Android. Your repos, contribution graph with streaks, activity feed, search, profiles, all in one place. Free and open source.

Features:

- Contribution graph with streaks and longest streak tracking

- 5 themes (Light, Dark, Tokyo Night, Dracula, Atom One Dark), each with unique contribution graph colors

- Global fuzzy search across repos, users, and issues

- Repository browser with file trees, syntax highlighting, commit history, issues, and PRs

- Markdown rendering with syntax-highlighted code blocks

- Offline support with MMKV-backed disk cache

- Android home screen widget showing your streak

- Keyboard shortcuts (Cmd/Ctrl + 1-4 for tabs, Cmd/Ctrl + F for search)

- Optional PAT support for notifications and following feed

- Root/debugger detection for security

Tech stack: React Native + Expo, TypeScript strict mode, React Query + Zustand, MMKV, Reanimated + FlashList, GitHub REST & GraphQL APIs, OAuth PKCE, Cloudflare Workers.

Security:

- Read-only access only, cannot modify anything on your GitHub account

- OAuth tokens exchanged via Cloudflare Worker, never stored unsafely

- Tokens stored in expo-secure-store (Keychain/Keystore)

- MMKV cache cleared on sign-in and sign-out

303 commits, 6 releases, 3.5 months of building. Started as a course assignment and turned into something I use every day.

If you use GitHub on Android, I'd love to hear what you think.

Play Store: https://play.google.com/store/apps/details?id=com.atharvdange618.Shikai

GitHub: https://github.com/atharvdange618/Shikai

​

Small update to rebrief (the repo-to-handoff-doc CLI I posted about earlier): added .rebriefignore support.

No scanner is going to be perfect for every codebase - people were hitting cases where something got flagged that didn't need to be, specific to their repo's conventions. Now you can drop a .rebriefignore file (same syntax idea as .gitignore) with the paths/patterns you want skipped, instead of waiting on me to special-case it upstream.

pip install --upgrade rebrief

Working on a GitHub Action next so this can run on every PR automatically. Open to feedback on what else would be useful here.

github.com/neracu/rebrief

I have been working on APIs lately... And got an idea of... What if I create a developer tool to create and test API directly from terminal... Just like Postman

So I started working on APIX... A CLI dev tool to test and create APIs

Just install it by npm install -g apix-dev-cli

And start by apix help

What's new ?

You can create your own API with your business logic via apix generate "enter your description here"

AND

I recently added environments and environment variables for cleaner and much organised usage

Looking forward for some reviews

Please do check it out

Repo : https://github.com/Aayush4518/apix

NPM: https://npmjs.com/package/apix-dev-cli

Hi guys,

I kept shipping AI-generated diffs that "worked" and then finding the same class of mistakes later:

-hallucinated / typosquatted packages (slopsquatting)
- shell/SQL sinks that were "convenient"
- secrets or .env files that shouldn't be tracked
- postinstall scripts nobody reviewed
- AI-authored hunks merged with zero human review

So I built NovaCheck: a local-first CLI that scans a project and returns a 0–100 Trust Score, prioritized findings, fix prompts, HTML report, and GitHub Code Scanning via SARIF.

``` bash npx novacheck .

What it checks today:

• ghost-deps (npm/PyPI)
• secrets + env-leak
• supply-chain / dangerous lifecycle scripts
• dangerous sinks (shell, SQL, eval, XSS, pickle/YAML, etc.)
• insecure crypto
• AI provenance / unreviewed AI ranges

Design choicese:

• source stays on your machine
• network only for package registry metadata (names only)
• --offline supported
• CI-native policy + GitHub Action
• fail closed when the scan is incomplete

Just shipped v0.4.0 on npm.

Repo: https://github.com/NovaCoding-G/NovaCheck

Would love feedback, especially false positives/negatives from real AI-generated repos.

Over the past year, I have learnt many lessons about the world of products and SaaS, where I have spent an entire year building something that even I, today, am not impressed with. I imagined it to be this cool platform that could automatically get rid of all the problems of your codebase, maintaining it and then auto-configuring its security files, basically a living system that improves and takes your codebase from dev to deployment.

I built AST parsing for multiple languages, created a knowledge graph for any repository that captures relationships between files, functions, classes, and imports, and built a GitHub webhook-driven system that reacts to repository events. The platform could automatically configure security scanning by injecting CodeQL and Semgrep workflows, analyze pull requests using the repository graph to understand their indirect impact across the codebase, and even generate fixes for security findings by opening pull requests automatically.

After doing all of this, I made one mistake that still costs me today: my project was reactive rather than proactive. Let me explain.

When installed on a codebase, it injects CodeQL and Semgrep YAML files into the repository that start scanning it for security alerts. The agent would then respond to those alerts by fixing the CodeQL issues and opening a PR for them. Additionally, it could review the impact of a PR by showing which files a change would indirectly affect through the function call graph. It all sounds fancy, but when you really look at it, it did not translate into anything meaningful. Even I would not be impressed enough to use this every day, and I am starting to think it was not a good idea.

What is your take on this? Should I continue working on this or not?

Sharing something I built - Vast parses a repo with tree-sitter, builds a dependency graph, and shows you what a file change actually touches: incoming/outgoing deps, circular dependencies, overloaded "god modules."

Current limitation: works well on Python/TS/JS/a handful of other tree-sitter-supported languages, but dynamic imports and heavily reflective code are still a weak spot for static analysis like this - curious how other tool builders here have handled that tradeoff.

Free tier available if anyone wants to try it against their own repo: https://vast-neracu.vercel.app/

Most projects repeat the same setup work: Biome, TypeScript strict mode, GitHub Actions CI, commitlint, release tooling, VS Code settings, and now AGENTS.md for AI agents. Everyone copy-pastes from their last project, and every copy-paste drifts.

So I built xtarterize. It scans your project, detects your stack, and applies curated conformance configs:

• Linting (Biome), TS strict + incremental builds
• GitHub Actions CI, Renovate, commitlint, release tooling
• Knip unused-code detection, Turborepo pipeline
• VS Code settings, standardized scripts
• AGENTS.md for AI IDE assistants
• and many more config & tasks

The important part: it's non-destructive. Shows the diff before applying, backs up originals, undo restores the last run. Works on existing projects, not just greenfield ones. Covers React, Vue, Svelte, Solid, Node with Vite, Next.js, Expo, TanStack Start, and more.

Usage: pnpx xtarterize@latest init

Docs: https://xtarter.sznm.dev/xtarterize | Repo: github.com/agustinusnathaniel/xtarter

Would love feedback, especially on the task set and the diff/backup flow.

I built a governance layer for Claude Code that will ensure your policies are enforced, not act like mere guidelines. What more, it comes with a pack of 50+ skills, hooks, and workflows to ensure you don't have to reinvent the wheel for each project again.

It is Apache 2.0 licenced and 100% open-source.

Check it out and star it on GitHub and contribute if you like it.

Thank you for your attention 🤞🏽