All files containing code should be top level in the repo, never nested in a directory.

All JSONs should be typed. Basically everything should have a type, and the types should be checked.

Types should be immutable, except for one tiny part of the system where they aren’t, for the purpose of making the system fast.

No comments, except for in-line comments where the code isn’t self-explanatory, or where something is implict.

Barely anything should be implicit - everything should be explicit if it doesn’t clutter the code too much. If it clutters the code too much, maybe the code should be redesigned.

Code reviews shouldn’t exist.

Code should be pushed straight to master.

Code reviews should be two people sitting in a room and discussing code together, as a dialog.

Fields shouldn’t have default values. Types can have a default object, but individual fields should never be default.

Refactoring should be a frequent and regular exercise.

No READMEs.

No confluence, jira, dropbox paper, google docs, design docs. It’s all code, just write code. Anything informal should be discussed between coworkers, then the interface should be agreed upon, then the code should be written. The interface can be described via code & types.

In order of importance, code should be beautiful, correct, and efficient.

Code shouldn’t be shared across teams. Interfaces should be agreed upon, but no code shall cross teams.

The number of repos a team manages should fit on one hand.

Standups should be done standing up, without laptops. Standups should be a checkin for the team, where they get a chance to bring things up with the team. It should be a discussion: how is X going? I had an idea for Y. Do we know anything about Z? There shouldn’t be a need to say what you did the previous day, what your plan is for the day, and what your blockers are. Chunking work into these buckets is arbitrary and doesn’t always make sense.

Arguably the most important hot take, which is similar to the standup hot take: all planning is an iterative process and requires dynamic, strategic, intelligent individuals (humans) assessing and re-assessing. Just as with standups, imposing some kind of artificial structure not only a) distracts from the essence of what is going on, but b) limits the action space of what can be done. Code is rigid, static, fixed, but developing code, especially across teams and individuals, should be a flexible, dynamic process. Having someone strategize and think outside the box is essential, instead of merely setting deadlines and checking boxes and checking how complete tasks are.

Jira should be abolished. Each person should have a todo list in their preferred method (mine being a single text file that I update daily) that indicates the work that needs to be done, and people should sync up on their todo lists to make sure that they’re all aligned. This should be done via discussion, not via tool like jira. No one should have to use anyone else’s preferred todo list method, and no one should touch anyone else’s todo list.

When using python, no setuptools. No conda, use virtualenv only. No semantic versioning. Code is code. The code in master is the code. We can look at the code history, but we shouldn’t need to.